Math::Series defines a class for simple mathematic series with a recursive
definition such as x_(n+1) = 1 / (x_n + 1). Such a recursive definition is
treated as a sequence whose elements will be added to form a series. You
can refer to the previous sequence element as well as to the current index
in the series. Creation of a Math::Series object is described below in the
paragraph about the constructor.
Math::Series uses Math::Symbolic to parse and modify the recursive
sequence definitions. That means you specify the sequence as a string
which is parsed by Math::Symbolic. Alternatively, you can pass the
constructor a Math::Symbolic tree directly.
Because Math::Series uses Math::Symbolic for its implementation, all
results will be Math::Symbolic objects which may contain other variables
than the sequence variable and the iterator variable.
Each Math::Series object is an iterator to iterate over the elements of
the series starting at the first element (which was specified by the
starting element, the second argument to the new() constructor). It offers
facilities to cache all calculated elements and access any element
directly, though unless the element has been cached in a previous
calculation, this is just a shortcut for repeated use of the iterator.
Why3 is a platform for deductive program verification. It provides a rich
language for specification and programming, called WhyML, and relies on
external theorem provers, both automated and interactive, to discharge
verification conditions. Why3 comes with a standard library of logical
theories (integer and real arithmetic, Boolean operations, sets and maps,
etc.) and basic programming data structures (arrays, queues, hash tables,
etc.). A user can write WhyML programs directly and get correct-by-
construction OCaml programs through an automated extraction mechanism.
WhyML is also used as an intermediate language for the verification of C,
Java, or Ada programs.
Why3 is a complete reimplementation of the former Why platform. Among the
new features are: numerous extensions to the input language, a new
architecture for calling external provers, and a well-designed API,
allowing to use Why3 as a software library. An important emphasis is put
on modularity and genericity, giving the end user a possibility to easily
reuse Why3 formalizations or to add support for a new external prover if
wanted.
The idea is that IPFilter in its current state can already do a simple L4
round-robin in its NAT rules. However, it does not detect or sense when a
service and/or host is down. It will continue to send requests to a downed
service/host.
However, IPFilter lets us add and remove rules on-the-fly so it should be
possible to build a daemon that lets you specify "clusters". In each cluster
you would specify its members/hosts and services. As well as a health-check
for the service to determine its current state.
Once a service was deemed "up" we would add a Round-Robin rule to the NAT
table, and naturally, the reverse once we detect a service as being "down".
In addition to this, this program can optionally add ipf rules to log for RST
(reset) packets coming from the members of your clusters. In the situations
where the software/port goes down, but the host itself is still working, we
would detect failure instantly. (Since the forwarded connections to the service
would trigger a RST packet back). If this option is enabled, l4ip spawns the
"ipmon" command to monitor for the "log" entries given when such a packet is
detected. l4ip will then mark the service down. This is an add-on feature and
is strictly not necessary for functional usage. It is currently only supported
for TCP.
AI::Categorizer is a framework for automatic text categorization. It
consists of a collection of Perl modules that implement common
categorization tasks, and a set of defined relationships among those
modules. The various details are flexible - for example, you can choose
what categorization algorithm to use, what features (words or otherwise)
of the documents should be used (or how to automatically choose these
features), what format the documents are in, and so on.
The basic process of using this module will typically involve obtaining a
collection of pre-categorized documents, creating a "knowledge set"
representation of those documents, training a categorizer on that
knowledge set, and saving the trained categorizer for later use. There are
several ways to carry out this process. The top-level AI::Categorizer
module provides an umbrella class for high-level operations, or you may
use the interfaces of the individual classes in the framework.
A simple sample script that reads a training corpus, trains a categorizer,
and tests the categorizer on a test corpus, is distributed as eg/demo.pl .
DeuTex is a tool to work with WAD files for Doom, Heretic, Hexen, and Strife.
It can be used to extract the lumps from a WAD and save them as individual
files. Conversely, it can also build a WAD from separate files. When
extracting a lump to a file, it does not just copy the raw data, it converts
it to an appropriate format (such as PPM for graphics, Sun audio for samples,
etc.). Conversely, when it reads files for inclusion in PWADs, it does the
necessary conversions (for example, from PPM to Doom picture format). In
addition, DeuTex has functions such as merging WADs, etc. If you're doing
any WAD hacking beyond level editing, DeuTex is a must.
paq is a family of archivers with the best lossless compression ratios now
available across a wide variety of test data, according to several benchmarks.
A comparison of paq to other compression methods, on a 2GHz T3200, when
compressing a large text file:
Format Size Time (sec) Memory
comp decomp
----------- --------- -------------- -------
Uncompressed 3,152,896
compress 1,319,521 1.6 0.2 .1 MB
gzip -9 1,022,810 0.7 0.1 .1 MB
bzip2 -9 860,097 0.6 0.4 5 MB
p7zip (7z) 824,573 1.5 0.1 195 MB
xz -6 822,016 ? ? ?
zpaq c1 (fast) 806,959 2 2 38 MB
zpaq c2 (mid) 699,191 8 8 112 MB
zpaq c3 (max) 644,190 20 20 246 MB
The port uses the open ZPAQ specification, and contains: a public-domain C++
API for reading and writing ZPAQ compressed data to or from files or objects
in memory; serial and multi-threaded archivers; extra preprocessors for
compression; and stubs for creating self-extracting archives.
RoadMap is a program for Linux that displays street maps. The maps are
provided by the US Census Bureau, and thus only cover the US.
RoadMap is at an early stage of development. At this time there are no
routing features implemented yet. RoadMap can only display the map around
a specified street address or follow a GPS device (using gpsd). The plan
for the future is to implement some navigation features similar to those
found in commercial street navigation systems.
RoadMap uses a binary file format for representing the maps that is compact
enough to allow the storage of many maps on a Compact Flash or MultiMedia
card. The map of Los Angeles county takes about 10 Mbytes of flash space.
RoadMap comes with a set of tools to convert the US Census bureau data
into its own map format.
abcMIDI is James Allwright's collection of abc <-> MIDI
conversion utilities, plus YAPS to convert abc files to
PostScript for printing music scores.
midi2abc - program to convert MIDI format files to abc notation.
abc2midi - converts abc file to MIDI file(s).
abc2abc - a simple abc checker/re-formatter/transposer.
mftext - gives a verbose description of what is in a MIDI file.
yaps - an abc to PostScript converter.
Also includes:
abcguide.txt - how to write abc files for these programs
demo.abc - a collection of sample abc tunes
Check ${PREFIX}/share/doc/abcmidi/ for these and other docs.
The abc format is plain text, but you might optionally install
a MIDI player (timidity) and a PostScript viewer (gv with ghostscript).
Oggz provides a simple programming interface for reading and writing
Ogg files and streams. Ogg is an interleaving data container developed
by Monty at Xiph.Org, originally to support the Ogg Vorbis audio
format.
liboggz supports the flexibility afforded by the Ogg file format while
presenting the following API niceties:
* Strict adherence to the formatting requirements of Ogg bitstreams,
to ensure that only valid bitstreams are generated
* A simple, callback based open/read/close or open/write/close interface
to raw Ogg files
* A customisable seeking abstraction for seeking on multitrack Ogg data
* A packet queue for feeding incoming packets for writing, with
callback based notification when this queue is empty
* A means of overriding the IO functions used by Oggz, for easier
integration with media frameworks and similar systems.
* A handy table structure for storing information on each logical
bitstream
Bonnie++ is a benchmark suite that is aimed at performing a number of
simple tests of hard drive and file system performance. Then you can
decide which test is important and decide how to compare different
systems after running it. I have no plans to ever have it produce a
single number, because I don't think that a single number can be useful
when comparing such things.
The main program tests database type access to a single file (or a set
of files if you wish to test more than 1G of storage), and it tests
creation, reading, and deleting of small files which can simulate the
usage of programs such as Squid, INN, or Maildir format email.