Free suffix tree implementation software for linux

Bellagio is a sample implementation of OpenMAX IL for Linux.
It enables software developers and ISVs to familiarize themselves with the OpenMAX IL API and to develop their own OpenMAX multimedia and streaming media components for mobile devices, including codecs, video I/O, and audio mixers.
Included sample components comply with the OpenMAX base and interoperability profiles and can be tunnelled together.
Main features:
- a shared library with the IL core and a "reference" OpenMAX component
- a number of OpenMAX components which pass Khronos conformance tests
- a set of GStreamer plugins that use the IL API (not available yet)
Enhancements:
New video components:
- ffmpeg based MPEG4/H.264 decoder
- color converter component YUV -> RGB
- video renderer based on devFB
New audio component:
- audio file reader based on ffmpeg audio format
- volume component
Fixed known bugs:
- FFMPEG audio decoder now works on FC6 and other distributions with the latest ffmpeg release (0.4.9-0.35.20070204)
Known pending bugs:
- some ogg streams can not be decoded properly
- the tunneling between file reader, mp3 dec based on ffmpeg - alsa sink ends in a deadlock sometimes.
- This behavior has been detected some times using FC6 and UBUNTU, not with the FC4
Full list of components:
Audio:
- ogg decoder based on libvorbis (stand alone components, and multiple roles component)
- mp3 decoder based on mad decoder
- mp3 decoder based on ffmpeg (multiple roles component)
- volume component
- alsa audio sink
- ffmpeg audio file reader (to be used with mp3 ffmpeg decoder)
Video:
- MPEG4 decoder based on ffmpeg (multiple roles component)
- H.264 decoder based on ffmpeg (multiple roles component)
- Color converter based on ffmpeg
- video renderer based on devFB
- Major additions to the 0.2
- New port classes
The components are:
- multiple formats audio decoder component that supports mp3 and ogg audio formats
- alsa sink component
- all the other components are NOT compatible with the new architecture.
- They have been removed and will be ported to the new architecture in a further delivery

Fast MD5 Implementation in Java is a heavily optimized implementation of the MD5 hashing algorithm written in Java.
Fast MD5 Implementation in Java includes an optional native method for even greater speed improvements.
How Fast Is It?
Short answer:Much faster than any other Java implementation that I have tested and (surprisingly) even faster than the native, non-Java MD5 implementation on some systems.
Long answer:First of all, it is important to note that the term "fast" is used here in relative terms. The implementation of the MD5 message digest algorithm available on this page is written in Java and is fast compared with other implementations written in Java, both because it is heavily optimized by itself and because there is an optional native method that makes it even faster when the platform supports it. How it compares to a sensible implementation written in a language, such as C, that is compiled directly to machine code, is heavily dependent upon how good of a job the JIT compiler in your JVM does in compiling the code or whether you are able to use the optional native method.
Enhancements:
- Martin West contributed a bug fix and some code refactoring to make all targets work out of the box in the Ant build file. Previously, the "dist" target did not work if the "docs" directory was not present.

Tree::Simple::SAX is a set of classes for using Tree::Simple with XML.

SYNOPSIS

use Tree::Simple::SAX;
use XML::SAX::ParserFactory;

my $handler = Tree::Simple::SAX::Handler->new(Tree::Simple->new());

my $p = XML::SAX::ParserFactory->parser(Handler => $handler);
$p->parse_string( Hello ! );

# this will create a tree like this:
# { tag_type => xml }
# { tag_type => string }
# { content => Hello , tag_type => CDATA }
# { tag_type => world }
# { content => !, tag_type => CDATA }

This is an early implementation of an XML::SAX handler which creates a Tree::Simple object hierarchy from the XML stream. It is currently in the proof-of-concept/experimental stages and I plan to add more features in the future.

If anyone else is interested in the development of this module, feel free to contact me (use the email in the AUTHOR section). I am always open to discussion, thoughts, criticism and especially patches.

XHTML Family Tree Generator project is a CGI Perl script together with some Perl modules that will create views of a family tree from a supplied data file. The data file is a simple text or Excel file listing the family members, parents, and other details.
It is possible to show a tree of ancestors and descendants for any person, showing any number of generations. Other facilities are provided for showing email directories, birthday reminders, facehall, and more. It has a simple configuration, makes heavy use of CGI (and other CPAN modules), generates valid XHTML, and has support for Unicode and multiple languages.
Enhancements:
- Italian support was added.

Deluxe Tree is a powerful, JavaScript-based site navigation menu. Deluxe Tree is a versatile, ready-made solution that allows professional and amateur Web developers to create superior navigation systems for their Web sites and Web applications.
It supports a special JavaScript API to change your menu "on-the-fly", animation effects, floating, drag-n-drop, state saving, XP Style, relative and absolute positions, animated icons and arrows, normal state, mouseover state, expanded state, unlimited submenus, separators, lines, and more.
Main features:
Compatibility
- Full cross-browser compatibility including IE, Netscape, Mozilla, Opera, Firefox, Konqueror and Safari
- on Windows, Mac OS and Linux
- Section 508 compliant
- Support for any doctypes
- Menu can be populated from a database using ASP, PHP, etc.
Seamless Integration
- Multiple menus on the same page
- Friendly to other scripts and css styles
- Any HTML code can be used within menu items
High Performance
- Generally loads faster than other page elements
- Performs perfectly with unlimited number of submenus and items
Easy Setup
- Comprehensible menu parameters for manual editing
Professional Look-n-Feel
- Fully customizable appearance, individual styles for each element
- Animation effects for submenus in XP Style
Unique Features
- Dragable, floating, state-saving menus
- Special JavaScript API for changing menu "on-the-fly"
Cost Effective
- Starts at just $39.95. Buy Now!
- Free for non-profit websites. Order Now!
- Full-functional free trial version.
Enhancements:
- Several .js modules were added.
- A special JavaScript API was added to change your menu "on-the-fly".
- New animation effects were added.

Tree::Simple::View::HTML is a Perl class for viewing Tree::Simple hierarchies in HTML.

SYNOPSIS

use Tree::Simple::View::HTML;

## a simple example
# use the defaults (an unordered list with no CSS)
my $tree_view = Tree::Simple::View::HTML->new($tree);

## more complex examples

# use the CSS properties
my $tree_view = Tree::Simple::View::HTML->new($tree => (
list_type => "ordered",
list_css => "list-style: circle;",
list_item_css => "font-family: courier;",
expanded_item_css => "font-family: courier; font-weight: bold",
));

# use the CSS classes
my $tree_view = Tree::Simple::View::HTML->new($tree => (
list_css_class => "myListClass",
list_item_css_class => "myListItemClass",
expanded_item_css_class => "myExpandedListItemClass",
));

# mix the CSS properties and CSS classes
my $tree_view = Tree::Simple::View::HTML->new($tree => (
list_css => "list-style: circle;",
list_item_css => "font-family: courier;",
expanded_item_css_class => "myExpandedListItemClass",
node_formatter => sub {
my ($tree) = @_;
return "" . $tree->getNodeValue()->description() . "";
}
));


# print out the tree fully expanded
print $tree_view->expandAll();

# print out the tree expanded along a given path (see below for details)
print $tree_view->expandPath("Root", "Child", "GrandChild");

Bio::Tree::Compatible is a Perl module for testing compatibility of phylogenetic trees with nested taxa.

SYNOPSIS

use Bio::Tree::Compatible;
use Bio::TreeIO;
my $input = new Bio::TreeIO(-format => newick,
-file => input.tre);
my $t1 = $input->next_tree;
my $t2 = $input->next_tree;

my ($incompat, $ilabels, $inodes) = $t1->is_compatible($t2);
if ($incompat) {
my %cluster1 = %{ $t1->cluster_representation };
my %cluster2 = %{ $t2->cluster_representation };
print "incompatible treesn";
if (scalar(@$ilabels)) {
foreach my $label (@$ilabels) {
my $node1 = $t1->find_node(-id => $label);
my $node2 = $t2->find_node(-id => $label);
my @c1 = sort @{ $cluster1{$node1} };
my @c2 = sort @{ $cluster2{$node2} };
print "label $label";
print " cluster"; map { print " ",$_ } @c1;
print " cluster"; map { print " ",$_ } @c2; print "n";
}
}
if (scalar(@$inodes)) {
while (@$inodes) {
my $node1 = shift @$inodes;
my $node2 = shift @$inodes;
my @c1 = sort @{ $cluster1{$node1} };
my @c2 = sort @{ $cluster2{$node2} };
print "cluster"; map { print " ",$_ } @c1;
print " properly intersects cluster";
map { print " ",$_ } @c2; print "n";
}
}
} else {
print "compatible treesn";
}

Bio::Tree::Compatible is a Perl tool for testing compatibility of phylogenetic trees with nested taxa represented as Bio::Tree::Tree objects. It is based on a recent characterization of ancestral compatibility of semi-labeled trees in terms of their cluster representations.

A semi-labeled tree is a phylogenetic tree with some of its internal nodes labeled, and it can represent a classification tree as well as a phylogenetic tree with nested taxa, with labeled internal nodes corresponding to taxa at a higher level of aggregation or nesting than that of their descendents.

Two semi-labeled trees are compatible if their topological restrictions to the common labels are such that for each node label, the smallest clusters containing it in each of the trees coincide and, furthermore, no cluster in one of the trees properly intersects a cluster of the other tree.

Future extensions of Bio::Tree::Compatible include a Bio::Tree::Supertree module for combining compatible phylogenetic trees with nested taxa into a common supertree.