Free compute checksum software for linux

Compute Portal Project is a portal project to produce a web based front end to a compute resource, such as a cluster, using PHP, mysql, and apache.
The intent is to allow non-programmers to use complex programs through an intuitive interface.
Enhancements:
- This is the third attempt to create a working release with an install script.
- The last two releases were plagued with copy and paste errors.
- This release is strictly a bugfix release that has been tested in a production environment.
- There may still be residual problems from the 0.8.8 to 0.8.9 transition that included the first install script and moved several directory locations.
- Please give this release a try.

CD-ROM Digest MD5 is a quick and dirty program to compute checksum of individual track.
It reports for each track:
- size (read)
- MD5 digest
Supports:
- multi track CD-ROM
- mode 1
- Linux ioctl()
- libmhash
Doesnt support:
- DVD
- Audio CD
- Multi session
- Other operating system
Known problem:
- Track are often bigger than the data written inside
- The program will report an error at the end of the data
- I dont know the way to detect the end of data.
- The checksum is good, and the size too.
Be aware:
- Track shorter than 4s -> 300 frames -> 614400 bytes are padded
- To check the checksum, pad the img/iso file to 614400 and run md5sum

crosssum project is a puzzle game to design and play cross sum games.

A cross sum puzzle is similar to a cross word puzzle, only the clues are the sums of sequences of single-digit numbers.

When in playing mode, you change the numbers by clicking on the square you wish to change. The number for the square is dependent on the position in the square that you click. Verifying play mode is identical to play except erroneous answers are highlighted.

In desiging mode you can change a square from an answer square to a blank square by clicking on it. One click toggles it. When you finished designing, use ^r to compute a puzzle for the board Squares are mirrored, if you want to override this press CTRL
while you click

The rules are:
1. Sums must be formed from strings of [1,9] with no dups
2. The grey squares are the answers, numbers above the diagonal are the answers for the sum to the right numbers below the diagonal are the answers for the sum below.

Config::Model::ValueComputer is a Perl module that provides configuration value computation.

SYNOPSIS

my $model = Config::Model->new() ;

$model ->create_config_class
(
name => "Master",
element
=> [
[qw/av bv/] => {type => leaf,
value_type => integer,
},
compute_int
=> { type => leaf,
value_type => integer,
compute => [ $a + $b, a => - av, b => - bv ],
min => -4,
max => 4,
},
[qw/sav sbv/] => {type => leaf,
value_type => string,
},
compute_string =>
=> { type => leaf,
value_type => string,
compute => [ meet $a and $b, a => - sav, b => - sbv ],
},
]
) ;

Math::Symbolic is a Perl module for symbolic calculations.

SYNOPSIS

use Math::Symbolic;

my $tree = Math::Symbolic->parse_from_string(1/2 * m * v^2);
# Now do symbolic calculations with $tree.
# ... like deriving it...

my ($sub) = Math::Symbolic::Compiler->compile_to_sub($tree);

my $kinetic_energy = $sub->($mass, $velocity);

Math::Symbolic is intended to offer symbolic calculation capabilities to the Perl programmer without using external (and commercial) libraries and/or applications.

Unless, however, some interested and knowledgable developers turn up to participate in the development, the library will be severely limited by my experience in the area. Symbolic calculations are an active field of research in CS.

There are several ways to construct Math::Symbolic trees. There are no actual Math::Symbolic objects, but rather trees of objects of subclasses of Math::Symbolic. The most general but unfortunately also the least intuitive way of constructing trees is to use the constructors of the Math::Symbolic::Operator, Math::Symbolic::Variable, and Math::Symbolic::Constant classes to create (nested) objects of the corresponding types.

Furthermore, you may use the overloaded interface to apply the standard Perl operators (and functions, see "OVERLOADED OPERATORS") to existing Math::Symbolic trees and standard Perl expressions.

Possibly the most convenient way of constructing Math::Symbolic trees is using the builtin parser to generate trees from expressions such as 2 * x^5. You may use the Math::Symbolic->parse_from_string() class method for this.
Of course, you may combine the overloaded interface with the parser to generate trees with Perl code such as "$term * 5 * sin(omega*t+phi)" which will create a tree of the existing tree $term times 5 times the sine of the vars omega times t plus phi.

There are several modules in the distribution that contain subroutines related to calculus. These are not loaded by Math::Symbolic by default. Furthermore, there are several extensions to Math::Symbolic availlable from CPAN as separate distributions. Please refer to "SEE ALSO" for an incomplete list of these.

For example, Math::Symbolic::MiscCalculus come with Math::Symbolic and contains routines to compute Taylor Polynomials and the associated errors.
Routines related to vector calculus such as grad, div, rot, and Jacobi- and Hesse matrices are availlable through the Math::Symbolic::VectorCalculus module. This module is also able to compute Taylor Polynomials of functions of two variables, directional derivatives, total differentials, and Wronskian Determinants.

Some basic support for linear algebra can be found in Math::Symbolic::MiscAlgebra. This includes a routine to compute the determinant of a matrix of Math::Symbolic trees.

Text::Diff3::DiffHeckel is a two-way diff plug-in.

SYNOPSIS

use Text::Diff3;
my $f = Text::Diff3::Factory->new;
my $p = $f->create_diff;
my $mytext = $f->create_text([ map{chomp;$_} < F0 > ]);
my $original = $f->create_text([ map{chomp;$_} < F1 > ]);
my $diff2 = $p->diff( $origial, $mytext );
$diff2->each(sub{
my( $r ) = @_;
print $r->as_string, "n";
if ( $r->type ne d ) {
print -, $original->as_string_at( $_ ) for $r->rangeB;
}
if ( $r->type ne a ) {
print +, $mytext->as_string_at( $_ ) for $r->rangeA;
}
});

ABSTRACT

This is a package for Text::Diff3 to compute difference sets between two text buffers based on the P. Heckels algorithm. Anyone may change this to an another diff or a its wrapper module by a your custom Factory instance.

Text::Diff3 needs a support of computing difference sets between two text buffers (diff). As the diff(1) command, the required diff module creates a list of tipples recorded an information set of a change type (such as a, c, or d) and a range of line numbers between two text buffers.

Since there are several algorithms and their implementations for the diff computation, Text::Diff3 makes a plan independent on any specific diff routine. It calls a pluggable diff processor instance specified in a factory commonly used in Text::Diff3. Anyone may change diff plug-in according to text properties.

For users convenience, Text::Diff3 includes small diff based on the P. Heckels algorithm. On the other hands, many other systems use the popular Least Common Sequence (LCS) algorithm. The merits for each algorithm are case by case. In authors experience, two algorithms generate almost same results for small local changes in the text. In some cases, such as moving blocks of lines, it happened quite differences in results.Text::Diff3::DiffHeckel is a two-way diff plug-in.

pypt-offline is a utility for people using Debian (and distros based on debian) on a disconnected machine.
It helps in downloading the required data from another, high bandwidth Windows/Linux/Mac box.
Enhancements:
- Lots of updates were done.
- This is the first full release of pypt-offline, but it is still in beta.
- MD5 checksum support was added.
- Local cache check support was added.
- Progress bar support was added.
- Python optparse is used for option parsing.
- Zip archiving is supported.
- Many many more updates were made.

Crypt::DH is a Diffie-Hellman key exchange system.

SYNOPSIS

use Crypt::DH;
my $dh = Crypt::DH->new;
$dh->g($g);
$dh->p($p);

## Generate public and private keys.
$dh->generate_keys;

$my_pub_key = $dh->pub_key;

## Send $my_pub_key to "other" party, and receive "other"
## public key in return.

## Now compute shared secret from "other" public key.
my $shared_secret = $dh->compute_secret( $other_pub_key );

Crypt::DH is a Perl implementation of the Diffie-Hellman key exchange system. Diffie-Hellman is an algorithm by which two parties can agree on a shared secret key, known only to them. The secret is negotiated over an insecure network without the two parties ever passing the actual shared secret, or their private keys, between them.