Ports Search

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.