Free md5 hashing algorithm software for linux

Optimization Algorithm Toolkit is a workbench and toolkit for developing, evaluating, and playing with classical and state-of-the-art optimization algorithms on standard benchmark problem domains; including reference algorithm implementations, graphing, visualizations and much more. The project was developed initially by Jason Brownlee as a part of his Ph.D. program.
The goal of this project is to deliver obscure-and-prevalent, old-and-new optimization algorithms from research literature to both research scientists and algorithm practitioners alike. Algorithms include biologically inspired approaches such as evolutionary algorithms (genetic algorithms), swarm algorithms (ants and particle swarm), and immune system algorithms.
Also included are more conventional approaches such as approaches inspired by physics including simulated annealing and extremal optimization. Problem domains include numerical function optimization, traveling salesman problems, and protein folding all with many standard benchmark instances taken from research literature.
A user-friendly graphical interface is provided to rapidly evaluate and compare algorithm and problem configurations, visualize algorithm behavior, and graph algorithm performance over time. A robust, modular, and extensible framework underlies the platform to facilitate the easy addition and modification of algorithms, addition of new problem domains and problem instances as well as facilitate more advanced algorithm experimentation.
The algorithm implementations are extensible and easily support modification and applicaition to varied problem domains. Please report any bugs, feature requests or include your own algorithms by accessing the services on the project home website. This is an open source project (released under the GPL) so the source code is available. The project was compiled with Java 1.5 (update 9).
Enhancements:
- This release includes many framework and graphical interface fixes, as well as a few new algorithms to play with.

C Algorithms Library is a collection of commonly used Computer Science algorithms.
The focus is on code that is well documented and tested, portable, and reusable.
The C Programming Language has a much smaller standard library compared to other more modern programming languages such as Java or Python.
In particular, it lacks implementations of many common data structures and algorithms. This is a collection of such algorithms to attempt to alleviate this problem.
The source code is released under the Modified BSD license, and as such can be freely modified and reused in any project, either proprietary or free. It is written in 100% ANSI standard C.
Each algorithm is written to be independent from the other implementations, allowing particular algorithms to be included in projects as needed.
Data structures
Collections
ArrayList : Automatically resizing array.
Doubly linked list : A set of values stored in a list with links that point in both directions.
Singly linked list : A set of values stored in a list with links that point in one direction.
Queue : Double ended queue which can be used as a FIFO or a stack.
Set : Unordered set of values.
Mappings
Hash table : Collection of values which can be addressed using a key.
Trie : Fast mapping using strings as keys.
Binary search trees
AVL tree : Balanced binary search tree with O(log n) worst case performance.
Utility functions
All of the above data structures operate on void pointers. It is sometimes necessary to compare values (when sorting a list, for example) or generate a hash key (in a hash table or set). This is done by providing a pointer to a function which provides this functionality. The following functions provide this functionality for some common data types.
- Integer comparison and hash functions.
- String comparison and hash functions.
- Generic (void) pointer comparison and hash functions.

Algorithm::BinPack is a Perl module that can efficiently pack items into bins.

SYNOPSIS

Algorithm::BinPack efficiently packs items into bins. The bins are given a maximum size, and items are packed in with as little empty space as possible. An example use would be backing up files to CD, while minimizing the number of discs required.

my $bp = Algorithm::BinPack->new(binsize => 4);

$bp->add_item(label => "one", size => 1);
$bp->add_item(label => "two", size => 2);
$bp->add_item(label => "three", size => 3);
$bp->add_item(label => "four", size => 4);

for ($bp->pack_bins) {
print "Bin size: ", $_->{size}, "n";
print " Item: ", $_->{label}, "n" for @{ $_->{items} };
}

METHODS

new

Creates a new Algorithm::BinPack object. The maximum bin size is specified as a named argument binsize, and is required. A fudge factor may be specified as a named argument fudge. If a fudge factor is specified, item sizes will be rounded up to a number divisible by the fudge factor. This can help keep items with similar sizes in order by their labels.

my $bp = Algorithm::BinPack->new(binsize => 4);
my $bp = Algorithm::BinPack->new(binsize => 100, fudge => 10);

add_item

Adds an item to be packed into a bin. Required named arguments are label and size, but any others can be specified, and will be saved. An optional bin argument can be used to manually put an item into the specified bin.

$bp->add_item(label => one, size => 1);
$bp->add_item(label => two, size => 2, desc => The second numeral);
$bp->add_item(label => zero, size => 3, bin => 0);
$bp->add_item(qw(label three size 3));
$bp->add_item(qw(label four size 4 random key));

prefill_bin

(Deprecated method) add_item now knows how to handle the bin argument directly, so this method is redundant.

pack_bins

Packs the items into bins. This method tries to leave as little empty space in each bin as possible. It returns a list of hashrefs with the key size containing the total bin size, and items containing an arrayref holding the items in the bin. Each item is in turn a hashref containing the keys label, size, and any others added to the item. If a fudge factor was used, each item will contain a key fudgesize, which is the size this item was fudged to.

for my $bin ($bp->pack_bins) {
print "Bin size: ", $bin->{size}, "n";

for my $item (@{ $bin->{items} }) {
printf " %-6s %-20sn", $_, $item->{$_} for keys %{ $item };
print " ---n";
}
}

C Minimal Perfect Hashing Library encapsulates the newest and more efficient algorithms in an easy-to-use, production-quality, fast API. The library was designed to work with big entries that cannot fit in the main memory. It has been used successfully for constructing minimal perfect hash functions for sets with more than 100 million of keys, and we intend to expand this number to the order of billion of keys.
Main features:
- Fast.
- Space-efficient with main memory usage carefully documented.
- The best modern algorithms are available (or at least scheduled for implementation :-)).
- Works with in-disk key sets through of using the adapter pattern.
- Serialization of hash functions.
- Portable C code (currently works on GNU/Linux and WIN32 and is reported to work in OpenBSD and Solaris).
- Object oriented implementation.
- Easily extensible.
- Well encapsulated API aiming binary compatibility through releases.
- Free Software.
A perfect hash function maps a static set of n keys into a set of m integer numbers without collisions, where m is greater than or equal to n. If m is equal to n, the function is called minimal.
Minimal perfect hash functions are widely used for memory efficient storage and fast retrieval of items from static sets, such as words in natural languages, reserved words in programming languages or interactive systems, universal resource locations (URLs) in Web search engines, or item sets in data mining techniques. Therefore, there are applications for minimal perfect hash functions in information retrieval systems, database systems, language translation systems, electronic commerce systems, compilers, operating systems, among others.
The use of minimal perfect hash functions is, until now, restricted to scenarios where the set of keys being hashed is small, because of the limitations of current algorithms. But in many cases, to deal with huge set of keys is crucial. So, this project gives to the free software community an API that will work with sets in the order of billion of keys.
Probably, the most interesting application for minimal perfect hash functions is its use as an indexing structure for databases. The most popular data structure used as an indexing structure in databases is the B+ tree. In fact, the B+ tree is very used for dynamic applications with frequent insertions and deletions of records. However, for applications with sporadic modifications and a huge number of queries the B+ tree is not the best option, because practical deployments of this structure are extremely complex, and perform poorly with very large sets of keys such as those required for the new frontiers database applications.
For example, in the information retrieval field, the work with huge collections is a daily task. The simple assignment of ids to web pages of a collection can be a challenging task. While traditional databases simply cannot handle more traffic once the working set of web page urls does not fit in main memory anymore, minimal perfect hash functions can easily scale to hundred of millions of entries, using stock hardware.
As there are lots of applications for minimal perfect hash functions, it is important to implement memory and time efficient algorithms for constructing such functions. The lack of similar libraries in the free software world has been the main motivation to create the C Minimal Perfect Hashing Library (gperf is a bit different, since it was conceived to create very fast perfect hash functions for small sets of keys and CMPH Library was conceived to create minimal perfect hash functions for very large sets of keys). C Minimal Perfect Hashing Library is a portable LGPLed library to generate and to work with very efficient minimal perfect hash functions.
Enhancements:
- This release adds an implementation of a classical minimal perfect hash algorithm called fch.
- This is used as a basis for a new algorithm that can create minimal perfect hashes for billions of keys with less than four bits per key, and is ready to use.
- Suggestions and bugfixes from users have been incorporated.

Algorithm::DiffOld is a Perl module to compute `intelligent differences between two files / lists but use the old ( $callback,
DISCARD_A => $callback,
DISCARD_B => $callback,
},
$comparison_function );

COMPARISON FUNCTIONS

Each of the main routines should be passed a comparison function. If you arent passing one in, use Algorithm::Diff instead.

These functions should return a true value when two items should compare as equal.

For instance,

@lcs = LCS( @seq1, @seq2, sub { my ($a, $b) = @_; $a eq $b } );

but if that is all youre doing with your comparison function, just use Algorithm::Diff and let it do this (this is its default).

Or:

sub someFunkyComparisonFunction
{
my ($a, $b) = @_;
$a =~ m{$b};
}

@diffs = diff( @lines, @patterns, &someFunkyComparisonFunction );

which would allow you to diff an array @lines which consists of text lines with an array @patterns which consists of regular expressions.

This is actually the reason I wrote this version -- there is no way to do this with a key generation function as in the stock Algorithm::Diff.