Free price comparisons software for linux

Bio::SAGE::Comparison module compares data from serial analysis of gene expression (SAGE) libraries.

SYNOPSIS

use Bio::SAGE::Comparison;
$sage = Bio::SAGE::Comparison->new();

This module provides several tools for comparing data generated from serial analysis of gene expression (SAGE) libraries.

BACKGROUND

Serial analysis of gene expression (SAGE) is a molecular technique for generating a near-global snapshot of a cell population’s transcriptome. Briefly, the technique extracts short sequences at defined positions of transcribed mRNA. These short sequences are then paired to form ditags. The ditags are concatamerized to form long sequences that are then cloned. The cloned DNA is then sequenced. Bioinformatic techniques are then employed to determine the original short tag sequences, and to derive their progenitor mRNA. The number of times a particular tag is observed can be used to quantitate the amount of a particular transcript. The original technique was described by Velculescu et al. (1995) and utilized an ~14bp sequence tag. A modified protocol was introduced by Saha et al. (2002) that produced ~21bp tags.

PURPOSE

This module facilitates the comparison of SAGE libraries. Specifically:

1. Calculations for determining the statistical
significance of expression differences.
2. Dynamically convert longer-tag libraries to
a shorter type for comparison (e.g. comparing
a LongSAGE vs. a regular SAGE library).

Both regular SAGE (14mer tag) and LongSAGE (21mer tag) are supported by this module.

Statistical significance in library comparisons is calculated using the method described by Audic and Claverie (1997). Code was generated by directly porting the authors original C source.

Schema-compare is a script that will compares two database schema and show the differences side-by-side.
Schema-compare can also generate SQL statements that will alter the old database to match the schema of the new database.
The comparisons are correct, but the SQL statements at the bottom are not quite right, they are close to what is necessary, but probably not exactly right.
To install simply ungzip/untar the file wherever you want to put it in your web folder and then edit the include/config.inc.php file with the information needed to connect to the two databases you want to compare. Both databases need to be on the same database server and use the same username and password to connect to them.
Enhancements:
- This is the first release of schema-compare. It compares the database schema just fine, but the sql alter statements it creates could use some work.

Debt Payment Comparison Calculator project is a free, flexible tool for your Web site that does more than just calculate monthly payments.
In addition to what typical Web calculators do, which is grab the principle, interest rate, and the years to pay it off to generate your monthly payment, this calculator can tell you how long it would take you to pay off a debt if you increased or decreased the payment amount.
Each time the user uses the calculator, it saves the information so that the user can compare different payment scenarios. At any time, the user can clear the data and start over. They can also color-group different scenarios for easy visual reference.
Main features:
- Stores calculations in a session variable, so users can compare different payment scenarios, side by side without the use of a database.
- Ability to color-code the scenarios by clicking on them, making it easy to visually sort the results
- Works fine without Javascript enabled
- Simple code to work with, easy to adjust to specific needs
- Styles and scripts are already in external files, making the web page search engine ready out of the box!

SYNOPSIS

use Array::Compare;

my $comp1 = Array::Compare->new;
$comp->Sep(|);
$comp->Skip({3 => 1, 4 => 1});
$comp->WhiteSpace(0);
$comp->Case(1);

my $comp2 = Array::Compare->new(Sep => |,
WhiteSpace => 0,
Case => 1,
Skip => {3 => 1, 4 => 1});

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

$comp1->compare(@arr1, @arr2);
$comp2->compare(@arr1, @arr2);

If you have two arrays and you want to know if they are the same or different, then Array::Compare will be useful to you.
All comparisons are carried out via a comparator object. In the simplest usage, you can create and use a comparator object like this:

my @arr1 = 0 .. 10;
my @arr2 = 0 .. 10;

my $comp = Array::Compare->new;

if ($comp->compare(@arr1, @arr2)) {
print "Arrays are the samen";
} else {
print "Arrays are differentn";
}

Notice that you pass references to the two arrays to the comparison method.

Internally the comparator compares the two arrays by using join to turn both arrays into strings and comparing the strings using eq. In the joined strings, the elements of the original arrays are separated with the ^G character. This can cause problems if your array data contains ^G characters as it is possible that two different arrays can be converted to the same string.

To avoid this, it is possible to override the default separator character, either by passing and alternative to the new function

my $comp = Array::Compare->new(Sep => |);

or by changing the seperator for an existing comparator object

$comp->Sep(|);

In general you should choose a separator character that wont appear in your data.

You can also control whether or not whitespace within the elements of the arrays should be considered significant when making the comparison. The default is that all whitespace is significant. The alternative is for all consecutive white space characters to be converted to a single space for the pruposes of the comparison. Again, this can be turned on when creating a comparator object:

my $comp = Array::Compare->new(WhiteSpace => 0);

or by altering an existing object:

$comp->WhiteSpace(0);

You can also control whether or not the case of the data is significant in the comparison. The default is that the case of data is taken into account. This can be changed in the standard ways when creating a new comparator object:

my $comp = Array::Compare->new(Case => 0);

or by altering an existing object:

$comp->Case(0);

In addition to the simple comparison described above (which returns true if the arrays are the same and false if theyre different) there is also a full comparison which returns a list containing the indexes of elements which differ between the two arrays. If the arrays are the same it returns an empty list. In scalar context the full comparison returns the length of this list (i.e. the number of elements that differ). You can access the full comparision in two ways. Firstly, there is a DefFull attribute. If this is true then a full comparison if carried out whenever the compare method is called.

my $comp = Array::Compare->new(DefFull => 1);
$comp->compare(@arr1, @arr2); # Full comparison

$comp->DefFull(0);
$comp->compare(@arr1, @arr2); # Simple comparison

$comp->DefFull(1);
$comp->compare(@arr1, @arr2); # Full comparison again

Secondly, you can access the full comparison method directly

$comp->full_compare(@arr1, @arr2);

For symmetry, there is also a direct method to use to call the simple comparison.

$comp->simple_compare(@arr1, @arr2);

The final complication is the ability to skip elements in the comparison. If you know that two arrays will always differ in a particular element but want to compare the arrays ignoring this element, you can do it with Array::Compare without taking array slices. To do this, a comparator object has an optional attribute called Skip which is a reference to a hash. The keys in this hash are the indexes of the array elements and the values should be any true value for elements that should be skipped.

For example, if you want to compare two arrays, ignoring the values in elements two and four, you can do something like this:

my %skip = (2 => 1, 4 => 1);
my @a = (0, 1, 2, 3, 4, 5);
my @b = (0, 1, X, 3, X, 5);

my $comp = Array::Compare->new(Skip => %skip);

$comp->compare(@a, @b);

This should return true, as we are explicitly ignoring the columns which differ.

Of course, having created a comparator object with no skip hash, it is possible to add one later:

$comp->Skip({1 => 1, 2 => 1});

or:

my %skip = (1 => 1, 2 => 2);
$comp->Skip(%skip);

To reset the comparator so that no longer skips elements, set the skip hash to an empty hash.

$comp->Skip({});

You can also check to see if one array is a permutation of another, i.e. they contain the same elements but in a different order.

if ($comp->perm(@a, @b) {
print "Arrays are permsn";
else {
print "Nope. Arrays are completely differentn";
}

In this case the values of WhiteSpace and Case are still used, but Skip is ignored for, hopefully, obvious reasons.

Charon aims to make it easy to start reselling Internet access via WiFi access point.
Charon installs onto a Linksys WiFi access point (or similar Linux device) and manages automatic price and access negotiation with local wireless customers, charging them via the mikolaj.cx settlement/micropayment system.
It will ultimately provide secure and fraud-resistant access by utilizing cash-based settlement, reputation tracking, and PKI-based non-repudiable contracts, to protect both the end-user and the access provider.
Enhancements:
- Cash prepayment support: prospective users can now pay with either cash or a credit card, at the option of the provider.
- Funds are transferred direct into their mikolaj.cx account and can be used at any Charon hotspot.
- Real-time balance query and account transaction history for the provider are now available from the administrative Web pages.
- PayPals Akamaized IP addresses are now detected and added to the firewall at every upstream reconnect, which should make Charons credit card payments usable out of the box anywhere in the world.

MaCollec is a Web-based Collections Manager written in PHP/Javascript. MaCollec Collections Manager is based on the AJAX technology to produce a nice-looking and pleasant interface. It doesnt require a database.
Items informations (including covers pictures) are retrieved from online libraries.
MaCollec works correctly only with a modern browser (like Mozilla Firefox, Opera, ...) which supports all major Web standards currently in use, including CSS 2.1, HTML 4.01, ECMAScript, DOM 2 ...
Main features:
- Easy install
- No database
- Fetches items (Books, Films, Albums) informations from online libraries.
- Multi-users (each user has his own folder)
- 2 different views to display folders (list and icons)
- Unlimited number of folders/subfolders
- Allows items properties to be updated
- Allows saving additional properties: loaning (date, person), purchase (date, price), notes and rating
- Wikipedia links

The primary use of this module by its author was to manage the Better SCM comparison of version control systems.

The Perl versions can generate either HTML or DocBook/XML. (the latter can be converted into many other formats). Also available is an XSLT stylesheet for transforming the XML markup into HTML.

CLSimilarImages is a command-line utility for finding visually similar images which may not be identical. It reads filenames from standard input, and outputs customisable results to standard output.

It can write similarity data to files for rapid future comparisons, with timestamps for quick updates. The project can compare one collection of images with itself, or two collections with each other. It works well in scripts or with pipes.