Free trees software for linux

XML::Handler::Trees is a PerlSAX handlers for building tree structures.

SYNOPSIS

use XML::Handler::Trees;
use XML::Parser::PerlSAX;

my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::Tree->new();
my $tree=$p->parse(Handler=>$h,Source=>{SystemId=>file.xml});

my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::EasyTree->new(Noempty=>1);
my $easytree=$p->parse(Handler=>$h,Source=>{SystemId=>file.xml});

my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::TreeBuilder->new();
$h->store_pis(1);
my $tree=$p->parse(Handler=>$h,Source=>{SystemId=>file.xml});

XML::Handler::Trees provides three PerlSAX handler classes for building tree structures. XML::Handler::Tree builds the same type of tree as the "Tree" style in XML::Parser.

XML::Handler::EasyTree builds the same type of tree as the "EasyTree" style added to XML::Parser by XML::Parser::EasyTree. XML::Handler::TreeBuilder builds the same type of tree as Sean M. Burkes XML::TreeBuilder. These classes make it possible to construct these tree structures from sources other than XML::Parser.

All three handlers can be driven by either PerlSAX 1 or PerlSAX 2 drivers. In all cases, the end_document() method returns a reference to the constructed tree, which normally becomes the return value of the PerlSAX driver.

Bio::NEXUS::TreesBlock is a Perl module that represents TREES block of a NEXUS file.

SYNOPSIS

if ( $type =~ /trees/i ) {
$block_object = new Bio::NEXUS::TreesBlock( $block_type, $block, $verbose );
}

If a NEXUS block is a Trees Block, this module parses the block and stores the tree data.

METHODS

new

Title : new
Usage : block_object = new Bio::NEXUS::TreesBlock($block_type, $commands, $verbose );
Function: Creates a new Bio::NEXUS::TreesBlock object and automatically reads the file
Returns : Bio::NEXUS::TreesBlock object
Args : type (string), the commands/comments to parse (array ref), and a verbose flag (0 or 1; optional)

clone

Title : clone
Usage : my $newblock = $block->clone();
Function: clone a block object (shallow)
Returns : Block object
Args : none

set_trees

Title : set_trees
Usage : $block->set_trees($trees);
Function: Sets the list of trees (Bio::NEXUS::Tree objects)
Returns : none
Args : ref to array of Bio::NEXUS::Tree objects

add_tree

Title : add_tree
Usage : $block->add_tree($tree);
Function: Add trees (Bio::NEXUS::Tree object)
Returns : none
Args : a Bio::NEXUS::Tree object

add_tree_from_newick

Title : add_tree_from_newick
Usage : $block->add_tree_from_newick($newick_tree, $tree_name);
Function: Add a tree (Bio::NEXUS::Tree object)
Returns : none
Args : a tree string in newick format and a name for the tree (scalars)

get_trees

Title : get_trees
Usage : $block->get_trees();
Function: Gets the list of trees (Bio::NEXUS::Tree objects) and returns it
Returns : ref to array of Bio::NEXUS::Tree objects
Args : none

get_tree

Title : get_tree
Usage : $block->get_tree($treename);
Function: Gets the first tree (Bio::NEXUS::Tree object) that matches the name given or the first tree if $treename is not specified. If no tree matches, returns undef.
Returns : a Bio::NEXUS::Tree object
Args : tree name or none

set_translate

Title : set_translate
Usage : $block->set_translate($translate);
Function: Sets the hash of translates for nodes names
Returns : none
Args : hash of translates

translate

Title : translate
Usage : $self->translate($num);
Function: Translates a number with its associated name.
Returns : integer or string
Args : integer
Method : Returns the name associated with that numbers translated name.
If it cant find an association, returns the number.

reroot_tree

Title : reroot_tree
Usage : $block->reroot_tree($outgroup,$root_position, $treename);
Function: Reroot a tree using an OTU as new outgroup.
Returns : none
Args : outgroup name, the distance before the root position and tree name

reroot_all_trees

Title : reroot_all_trees
Usage : $block->reroot_all_trees($outgroup, $root_position);
Function: Reroot all the trees in the treesblock tree. use an OTU as new outgroup
Returns : none
Args : outgroup name and root position

rename_otus

Title : rename_otus
Usage : $block->rename_otus(%translation);
Function: Renames nodes based on a translation hash
Returns : none
Args : hash containing translation (e.g., { old_name => new_name} )
Comments: nodes not included in translation hash are unaffected

select_otus

Name : select_otus
Usage : $nexus->select_otus(@otunames);
Function: select a subset of OTUs
Returns : a new nexus object
Args : a ref to array of OTU names

select_tree

Name : select_tree
Usage : $nexus->select_tree($treename);
Function: select a tree
Returns : a new nexus object
Args : a tree name

select_subtree

Name : select_subtree
Usage : $nexus->select_subtree($inodename);
Function: select a subtree
Returns : a new nexus object
Args : an internal node name for subtree to be selected

exclude_subtree

Name : exclude_subtree
Usage : $nexus->exclude_subtree($inodename);
Function: remove a subtree
Returns : a new nexus object
Args : an internal node for subtree to be removed

equals

Name : equals
Usage : $nexus->equals($another);
Function: compare if two NEXUS objects are equal
Returns : boolean
Args : a NEXUS object

kdtree project is a simple C library for working with KD-Trees.
Kd-trees are an extension of binary search trees to k-dimensional data. They facilitate very fast searching, and nearest-neighbor queries.
This particular implementation is designed to be efficient and very easy to use. It is completely written in ANSI/ISO C, and thus completely cross-platform.
Enhancements:
- This release fixes both reported bugs, and adds a contributed, more extensive, and well commented example program.

trigger is a lightweight, asynchronous notification mechanism to set off events in and across systems. The poor mans daily snapshot, glastree builds live backup trees, with branches for each day. Users directly browse the past to recover older documents or retrieve lost files. Hard links serve to compress out unchanged files, while modified ones are copied verbatim. A prune utility effects a constant, sliding window.

Tree::Visualize is a Perl module for visualizing Tree structures.

SYNOPSIS

use Tree::Visualize;
use Tree::Binary;

my $tree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);

my $visualize = Tree::Visualize->new($tree, ASCII, TopDown);
print $visualize->draw();

# +---+
# +--------| * |-------+
# | +---+ |
# +---+ +---+
# +--| + |--+ +--| + |--+
# | +---+ | | +---+ |
# +---+ +---+ +---+ +---+
# | 2 | | 2 | | 4 | | 5 |
# +---+ +---+ +---+ +---+

my $tree = Tree::Binary::Search->new();
foreach my $value (7, 3, 1, 0, 2, 5, 4, 6, 11, 9, 10, 8, 13, 12, 14) {
$tree->insert($value => $value);
}

my $visualize = Tree::Visualize->new($tree, ASCII, Diagonal);
print $visualize->draw();

# (7)-------------(11)-----(13)-(14)
# | | |
# | | (12)
# | |
# | (9)-(10)
# | |
# | (8)
# |
# (3)-----(5)-(6)
# | |
# | (4)
# |
# (1)-(2)
# |
# (0)

my $tree = Tree::Simple->new("test")
->addChildren(
Tree::Simple->new("test-1")
->addChildren(
Tree::Simple->new("test-1-1")
),
Tree::Simple->new("test-2"),
Tree::Simple->new("test-3")
);

my $visualize = Tree::Visualize->new($tree, ASCII, TopDown);
print $visualize->draw();

# |
# +------+
# | test |
# +------+
# ____________|_____________
# | | |
# +--------+ +--------+ +--------+
# | test-1 | | test-2 | | test-3 |
# +--------+ +--------+ +--------+
# |
# |
# +----------+
# | test-1-1 |
# +----------+

NOTE: This is very early release alpha software
The goal of this module is to provide a means of easily visualizing trees in a number of output formats and layouts. Currently only ASCII output and a limited number of formats are supported. There is some support for output as GraphViz dot files, but that is buggy at best right now.

As I said, this is alpha software, and so please dont expect it to do all that much. Many of the classes inside are not even implemented, and few if any are documented. I am releasing this to CPAN largely as a means of self-motivation, although I can make no promises about the speed of my progress.

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::Binary is a Object Oriented Binary Tree for Perl.

SYNOPSIS

use Tree::Binary;

# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)

# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);

# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"

# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);

# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"

# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);

# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"

# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);

# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"

# be sure to clean up all circular references
$btree->DESTROY();

This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.

Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.

This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.

This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.

Tree::PseudoIncLib is a Perl class for encapsulating a description of pseudo-INC array.

ABSTRACT

This module encapsulates a perl-type library description data and provides methods for manipulating that data. It is in no way associated with any real @INC array on the system. Instead, it works with so-called pseudo_INC incoming array that might be, or might be not directly associated with @INC defined for a particular user or a process on the system.

SYNOPSIS

# make sure to configure the log system properly.
#
use Tree::PseudoIncLib;
#
# class default object:
#
my $tree_obj = Tree::PseudoIncLib->new();
#
# another instance:
#
my $sp_obj = $tree_obj->new (
max_nodes => $my_max_nodes, # limit number of nodes
p_INC => $my_INC_copy_ref,
);
unless ( $sp_obj->from_scratch ) {
# something went wrong:
print ($sp_obj->status_as_string);
die;
}
# wewe got a description inside the object.
# we can export it to an appropriate form now...
#
my $src_html = $sp_obj->export_to_DHTML (
title => Test-Debug,
image_dir => data/images/,
icon_shaded => file_x.gif,
icon_folder_opened => folder_opened.gif,
icon_symlink => hand.right.gif,
tree_intend => 18,
row_class => r0,
css => , # use inline css
jslib => , # no jslib
overlib => js/overlib.js,
);
# ... and deploy the document from $src_html then...

Detailed description of Perl library on the system is extremely helpful for every perl developer. It could be benefitial for the system administrator too in order to ensure a proper structure of system libraries.

This module encapsulates the description data and provides methods for manipulating that data. It was initially developed as an Apache incorporated tool for the mod_perl development. The idea beside was pretty simple -- to provide developers with the tree of all available perl modules installed on the system and make all sources and documents viewable on network.

As a side effect of the first developed prototype, it appeared to be usefull additionally from the standpoint of proper configuration of @INC array on the system, particularly regarding the fact that some perl modules could be shaded by other ones carrying the same CPAN class name. It appears to be pretty easy to mark all shaded modules on the tree, providing helpful information for the system administrator.

It was noticed additionally that the process of creation of the tree is extremely time consuming, especially on busy web servers equiped with rich Perl libraries. On the other hand, the content of the libraries remains unchanged usualy pretty long time that is measured in days and weeks. So far, the separation of the process of creation of the tree from the process of deployment of the view to the client browser seems beneficial from the prospective of improvement of performance on busy systems. That was the main reason of creation of this module, making it possible to use the same API from the command line script or one running under the cron control.
Despite the initial purpose, this version of the module is in no way associated with any real @INC array on the system. Instead, this module works with so-called pseudo_INC incoming array that might be, or might be not directly associated with current @INC for a particular user/process on the system.