Free 2.0.3 software for linux

Text::WagnerFischer is an implementation of the Wagner-Fischer edit distance.

SYNOPSIS

use Text::WagnerFischer qw(distance);

print distance("foo","four");# prints "2"

print distance([0,1,2],"foo","four");# prints "3"


my @words=("four","foo","bar");

my @distances=distance("foo",@words);
print "@distances"; # prints "2 0 3"

@distances=distance([0,2,1],"foo",@words);
print "@distances"; # prints "3 0 3"

This module implements the Wagner-Fischer dynamic programming technique, used here to calculate the edit distance of two strings. The edit distance is a measure of the degree of proximity between two strings, based on "edits": the operations of substitutions, deletions or insertions needed to transform the string into the other one (and vice versa). A cost (weight) is needed for every of the operation defined above:

/ a if x=y (cost for letter match)
w(x,y) = | b if x=- or y=- (cost for insertion/deletion operation)
c if x!=y (cost for letter mismatch)

These costs are given through an array reference as first argument of the distance subroutine: [a,b,c]. If the costs are not given, a default array cost is used: [0,1,1] that is the case of the Levenshtein edit distance:

/ 0 if x=y (cost for letter match)
w(x,y) = | 1 if x=- or y=- (cost for insertion/deletion operation)
1 if x!=y (cost for letter mismatch)

This particular distance is the exact number of edit needed to transform the string into the other one (and vice versa). When two strings have distance 0, they are the same. Note that the distance is calculated to reach the _minimum_ cost, i.e. choosing the most economic operation for each edit.

CDlinux is a CD based mini Linux distribution, which runs from a CDROM. It aims to be a handy administration/rescue tool for system administrators as well as general users.
CDlinux is highly user configurable, supports a wide range of hardware (PCMCIA, SCSI, USB, etc.) and many networking protocols (FTP, SSH, NFS, SMB, DHCP, etc.).
CDlinux also has good support for CJK, especially Simplified Chinese.
These are some useful gadgets from CDlinux. Note, you do not need to download them, if you have downloaded CDlinux. They are already included. They are listed here just in case you may want to use them in a normal Linux installation, and dont want to download the whole CDlinux bundle. And they are also as examples on how works are done under Linux, in a better and more decent way comparing with other platforms.
file-opt (~1k) This shell script finds identical files in the CURRENT directory, and hard link them to save space. Its useful when building so called "N in 1" CD images like "Win2k 3in1" in Linux .
mkisofs-CJK (~380k) This is a patched version of mkisofs-2.0.3, it supports CJK joliet filenames. The original GB (Simplified Chinese) Code Page was derived from the official Linux kernel, and has some errors. I fixed this bug according to the correct cp936 file (~160k). This version can handle GB joliet filenames correctly now.
It also supports the new "joliet-long" parameter, and supports joliet filenames as long as 103 unicode characters (207 bytes). So you can even use it to build "WinPE" CD images in Linux.
The source of the CJK patch is available here (~390k). Note that, this patch is only a quick and dirty hack, I only tested it in Slackware-8.1.
ren2upper (~2k) When being invoked as "ren2upper", this script will change file/folder names in the CURRENT directory to upper case. And, if being invoked as "ren2lower", it will change them to lower case. Its useful when exchanging data between Unix and Windows hosts.
These gadgets are either shell scripts or compiled with gcc-2.95.3 and linked against glibc-2.2.5, so they should run happily on most recent Linux distributions.
Whats New in 0.5.9 Alpha Development Release:
- This release added support for auto-detecting the boot device, support for CDL_DEV=LABEL=xxx, CDL_DEV=UUID=xxx, and CDL_WAIT=n, and support for auto-detecting local partitions.
- The number of supported RAM disks and loop devices was increased to 255.
- Support for locales was improved.
- A ctrl-alt-del problem was fixed and some pkg upgrades were made.

BlockStop Proxy is a Firefox extension that allows you to view the current page or link using.

Adds a "View this page with BlockStop" or "Open Link Target with BlockStop" option to your Firefox right-click menu, depending on where you click. The BlockStop Proxy extension automatically encodes the target url to maintain anonymity.

Class::Bits is a Perl module with class wrappers around bit vectors.

SYNOPSIS

package MyClass;
use Class::Bits;

make_bits( a => 4, # 0..15
b => 1, # 0..1
c => 1, # 0..1
d => 2, # 0..3
e => s4 # -8..7
f => s1 # -1..0
);

package;

$o=MyClass->new(a=>12, d=>2);
print "o->b is ", $o->b, "n";

print "bit vector is ", unpack("h*", $$o), "n";

$o2=$o->new();
$o3=MyClass->new($string);

ABSTRACT

Class::Bits creates class wrappers around bit vectors.

Class::Bits defines classes using bit vectors as storage.
Object attributes are stored in bit fields inside the bit vector. Bit field sizes have to be powers of 2 (1, 2, 4, 8, 16 or 32).

There is a class constructor subroutine:

make_bits( field1 => size1, field2 => size2, ...)

exports in the calling package a ctor, accessor methods, some utility methods and some constants:

Sizes can be prefixed by s or u to define signedness of the field. Default is unsigned.

$class->new()

creates a new object with all zeros.

$class->new($bitvector)

creates a new object over $bitvector.

$class->new(%fields)

creates a new object and initializes its fields with the values in %fields.

$obj->new()

clones an object.

$obj->$field()
$obj->$field($value)

gets or sets the value of the bit field $field inside the bit vector.

$class->length
$obj->lenght

returns the size in bits of the bit vector used for storage.

$class->keys
$obj->keys

returns an array with the names of the object attributes

$obj->as_hash

returns a flatten hash with the object attributes, i.e.:
my %values=$obj->as_hash;

%INDEX

hash with offsets as used by vec perl operator (to get an offset in bits, the value has to be multiplied by the corresponding bit field size).

%SIZES

hash with bit field sizes in bits.

%SIGNED

hash with signedness of the fields

Bit fields are packed in the bit vector in the order specified as arguments to make_bits.

Bit fields are padded inside the bit vector, i.e. a class created like

make_bits(A=>1, B=>2, C=>1, D=>4, E=>8, F=>16);

will have the layout

AxBBCxxx DDDDxxxx EEEEEEEE xxxxxxxx FFFFFFFF FFFFFFFF

RSStool is a software to read, parse, merge and write RSS (and Atom) feeds.

Lately a new technology called "RSS feeds" has caught my attention I decided to make it successful by writing this small tool.

Usage:

rsstool [OPTION] FILE|URL...

Read, parse, merge and write RSS (and ATOM) feeds

Supports: RSS 0.9x, 1.0, 2.0 and ATOM 0.1, 0.2, 0.3

The RSS (or ATOM) feeds will be merged and re-sorted if you enter more than
one URL or FILEname

Options:
--version output version information and exit
--help display this help and exit
-q be quiet/less verbose
-s strip HTML code from RSS (or Atom) feeds
-r sort reverse
--html output as html (using -q will result in single line)
--txt output as plain text (using -q will result in single line)
-1 output as single line

--template=FILE|URL parse template file and replace tags with content
Tags: "< rsstool:url item=NUM >" url/link of item NUM
"< rsstool:title item=NUM >" title of item NUM
"< rsstool:desc item=NUM >" description of item
with NUM
"< rsstool:date item=NUM >" date of item NUM
"< rsstool:site item=NUM >" site where item with
NUM came from
Thats right, you could use/replace these custom tags in HTML
pages and upload them to a server who does only static HTML
"< rsstool:start item=NUM >" start of item NUM
"< rsstool:end item=NUM >" end of item NUM
These tags will be replaced with a "< !--" and a "-- >" if
the item NUM is empty
"< rsstool:updated >" rsstool notice (Thank You!)

--property=FILENAME output feed(s) into a property file
Layout: NAME_NUM=VALUE
NAME is "title", "url", etc..
NUM is an integer counting the items
VALUE is the content

App::ErrorCalculator is a Perl module that contains calculations with Gaussian Error Propagation.

SYNOPSIS

# You can use the errorcalculator script instead.

require App::ErrorCalculator;
App::ErrorCalculator->run();

# Using the script:
# errorcalculator

errorcalculator and its implementing Perl module App::ErrorCalculator is a Gtk2 tool that lets you do calculations with automatic error propagation.

Start the script, enter a function into the function entry field, select an input file, select an output file and hit the Run Calculation button to have all data in the input field processed according to the function and written to the output file.
Functions should consist of a function name followed by an equals sign and a function body. All identifiers (both the function name and all variables in the function body) should start with a letter. They may contain letters, numbers and underscores.

The function body may contain any number of constants, variables, operators, functions and parenthesis. The exact syntax can be obtained by reading the manual page for Math::Symbolic::Parser. Arithmetic operators (+ - * / ^) are supported. The caret indicates exponentiation. Trigonometric, inverse trigonometric and hyperbolic functions are implemented (sin cos tan cot asin acos atan acot sinh cosh asinh acoth). log indicates a natural logarithm.

Additionally, you may include derivatives in the formula which will be evaluated (analytically) for you. The syntax for this is: partial_derivative(a * x + b, x). (Would evaluate to a.)

In order to allow for errors in constants, the program uses the Math::SymbolicX::Error parser extension: use the error(1 +/- 0.2) function to include constants with associated uncertainties in your formulas.

The input files may be of any format recognized by the Spreadsheet::Read module. That means: Excel sheets, OpenOffice (1.0) spreadsheets, CSV (comma separated values) text files, etc.

The program reads tabular data from the spreadsheet file. It expects each column to contain the data for one variable in the formula.

a, b, c
1, 2, 3
4, 5, 6
7, 8, 9

This would assign 1 to the variable a, 2 to b and 3 to c and then evaluate the formula with those values. The result would be written to the first data line of the output file. Then, the data in the next row will be used and so on. If a column is missing data, it is assumed to be zero.

Since this is about errors, you can declare any number of errors to the numbers as demonstrated below:

a, a_1, a_2, b, b_1
1, 0.2, 0.1, 2, 0.3
4, 0.3, 0.3, 5, 0.6
7, 0.4, 0,1, 8, 0.9

Apart from dropping c for brevity, this example input adds columns for the errors of a and b. a has two errors: a_1 and a_2. b only has one error b_1 which corresponds to the error a_1. When calculating, a will be used as 1 +/- 0.2 +/- 0.1 in the first calculation and b as 2 +/- 0.3 +/- 0. The error propagation is implemented using Number::WithError so thats where you go for details.

The output file will be a CSV file similar to the input examples above.

Atari800 project is an Atari 8-bit computer and 5200 game system emulator for multiple platforms.
It runs on DOS, Windows, Amiga, Atari ST, Mac, and Linux/UNIX.
It includes support for Atari cartridge ROMs, popular Atari disk images files, running Atari binaries directly from the host system, and accessing the host filesystem from within the emulated Atari.
Main features:
- Atari 400, 800, 600 XL, 800XL, 130XE, 5200 Games System.
- 130XE compatible memory expansions: 320K, 576K, 1088K.
- Optional 4K RAM between 0xc000 and 0xcfff in 400/800 mode.
- Cycle-exact 6502 emulation, all unofficial instructions.
- Cycle-exact NMI interrupts, scanline-based POKEY interrupts.
- Cycle-exact ANTIC and GTIA emulation, all display modes.
- Player/Missile Graphics, exact priority control and collision detection.
- Exact POKEY registers (sound and random number generator).
- 8 disk drives, emulated at computer-to-drive communication and fast patched SIO levels.
- ATR, XFD, DCM, ATR.GZ and XFD.GZ disk images.
- Direct loading of Atari executable files and Atari BASIC programs.
- 42 cartridge types, raw and CART .
- Cassette recorder, raw and CAS images.
- Printer support.
- Files can be stored directly on your host computer via the H: device.
- Current emulation state can be saved in a state file.
- Sound support on Unix using "/dev/dsp".
- Stereo (two POKEYs) emulation.
- Joystick controller using numeric keypad.
- Real joystick support.
- Paddles, Atari touch tablet, Koala pad, light pen, light gun, ST/Amiga mouse, Atari trak-ball, joystick and Atari 5200 analog controller emulated using mouse.
- R-Time 8 emulation using host computer clock.
- Atari palette read from a file or calculated basing on user-defined parameters.
- Screen snapshots (normal and interlaced) to PCX and PNG files.
- Sound output may be written to WAV files.
- User interface on all versions supporting bitmapped graphics.
- R: device (the Atari850 serial ports) mapped to net or real serial port.