Free solution tree software for linux

STX B+ Tree project is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree.
The tree algorithms are based on the implementation in Cormen, Leiserson and Rivests Introduction into Algorithms, Jan Janninks paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementations correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments btree.h.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster.
Enhancements:
- This release introduces the demonstration program wxBTreeDemo.
- This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes.
- It allows the user to select different types of B+ tree instantiations: integer or string keys and different slot numbers.
- The user may insert and erase key/data pairs from the tree and run different search operations.
- The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows, and Mac OS X.

Gluon is a simple decision-tree daemon, written in Perl, that executes external programs (scripts) to determine the path-flow within the decision-tree.

Gluon project essentially operates as a basic IF-THEN-ELSE expert system that can be used to monitor and take action.

Linguistic Tree Constructor is a free program for building linguistic syntax trees from text. Linguistic Tree Constructor lets the user build the tree in a point-and-click fashion.
The program does no analysis on its own -- the user is completely free to draw the tree however he or she wishes. However, the program makes sure that the tree is a tree and not some other kind of graph.
Syntactic theories supported
Three "flavors" of trees are supported:
- "Generic" syntax trees,
- X-Bar syntax trees
- RRG (Role and Reference Grammar) syntax trees (the LSC and the LSNP)
Labeling of nodes
- The program supports adding "labels" to nodes. These labels are userdefinable, and can be used for such things as:
- Rhetorical Structure Theory analyses
- Other discourse-level analyses
- RRG operator-projection analyses
- Subject-Object-Predicate analyses
Main features:
- Draw syntax trees using point-and-click
- Both tree-view and brackets-view are supported
- Supports up to five interlinear lines at word-level
- Interlinear lines can be switched on and off individually
- Change magnification
- Unlimited undo
- Copy (parts of) tree to clipboard as BMP
- Printing + Print Preview
- Uses any font (even Unicode fonts)
- Supports right-to-left languages as well as left-to-right
- Import from straight text (plain text)
- Import from word-per-record SFM interlinear text
- ... and many more...
Enhancements:
- A number of crashes were fixed.
- A bug with magnification on OS X was fixed.
- The speed of interaction with the program was improved.

Bio::Tree::Tree is an implementation of TreeI interface.

SYNOPSIS

# like from a TreeIO
my $treeio = new Bio::TreeIO(-format => newick, -file => treefile.dnd);
my $tree = $treeio->next_tree;
my @nodes = $tree->get_nodes;
my $root = $tree->get_root_node;

This object holds handles to Nodes which make up a tree.

DBIx::OO::Tree is a Perl module to manipulate hierarchical data using the "nested sets" model.

SYNOPSYS

CREATE TABLE Categories (
id INTEGER UNSIGNED AUTO_INCREMENT PRIMARY KEY,
label VARCHAR(255),

-- these columns are required by DBIx::OO::Tree
parent INTEGER UNSIGNED,
lft INTEGER UNSIGNED NOT NULL,
rgt INTEGER UNSIGNED NOT NULL,
mvg TINYINT DEFAULT 0,

INDEX(lft),
INDEX(rgt),
INDEX(mvg),
INDEX(parent)
);

* * *

package Category;
use base DBIx::OO;
use DBIx::OO::Tree;

__PACKAGE__->table(Categories);
__PACKAGE__->columns(P => [ id ],
E => [ label, parent ]);

# note its not necessary to declare lft, rgt, mvg or parent. We
# declare parent simply because it might be useful, but
# DBIx::OO:Tree works with low-level SQL therefore it doesnt
# require that the DBIx::OO object has these fields.

# the code below creates the structure presented in [1]

my $electronics = Category->tree_append({ label => electronics });
my $tvs = $electronics->tree_append({ label => televisions });
my $tube = $tvs->tree_append({ label => tube });
my $plasma = $tvs->tree_append({ label => plasma });
my $lcd = $plasma->tree_insert_before({ label => lcd });
my $portable = $tvs->tree_insert_after({ label => portable electronics });
my $mp3 = $portable->tree_append({ label => mp3 players });
my $flash = $mp3->tree_append({ label => flash });
my $cds = $portable->tree_append({ label => cd players });
my $radios = Category->tree_append($portable->id,
{ label => 2 way radios });

# fetch and display a subtree

my $data = $electronics->tree_get_subtree({
fields => [qw( label lft rgt parent )]
});
my $levels = Category->tree_compute_levels($data);

foreach my $i (@$data) {
print x $levels->{$i->{id}}, $i->{label}, "n";
}

## or, create DBIx::OO objects from returned data:

my $array = Category->init_from_data($data);
print join("n", (map { x $levels->{$_->id} . $_->label } @$array));

# display path info

my $data = $flash->tree_get_path;
print join("n", (map { $_->{label} } @$data));

# move nodes around

$mp3->tree_reparent($lcd->id);
$tvs->tree_reparent($portable->id);
$cds->tree_reparent(undef);

$plasma->tree_move_before($tube->id);
$portable->tree_move_before($electronics->id);

# delete nodes

$lcd->tree_delete;

This module is a complement to DBIx::OO to facilitate storing trees in database using the "nested sets model", presented in [1]. Its main ambition is to be extremely fast at retrieving data (sacrificing for this the performance of UPDATE-s, INSERT-s or DELETE-s). Currently this module requires you to have these columns in the table:

- id: primary key (integer)
- parent: integer, references the parent node (NULL for root nodes)
- lft, rgt: store the node position
- mvg: used only when moving nodes

"parent" and "mvg" are not esentially required by the nested sets model as presented in [1], but they are necessary for this module to work. In particular, "mvg" is only required by functions that move nodes, such as tree_reparent(). If you dont want to move nodes around you can omit "mvg".

Retrieval functions should be very fast (one SQL executed). To further promote speed, they dont return DBIx::OO blessed objects, but an array of hashes instead. Its easy to create DBIx::OO objects from these, if required, by calling DBIx::OO->init_from_data() (see DBIx::OO for more information).

Insert/delete/move functions, however, need to ensure the tree integrity. Heres what happens currently:

- tree_append, tree_insert_before, tree_insert_after -- these execute
one SELECT and two UPDATE-s (that potentially could affect a lot of
rows).

- tree_delete: execute one SELECT, one DELETE and two UPDATE-s.

- tree_reparent -- executes 2 SELECT-s and 7 UPDATE-s. I know, this
sounds horrible--if you have better ideas Id love to hear them.

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

XML::Simple::Tree is a tree object extension for XML::Simple data structures.

SYNOPSIS

## script 1
## create XML::Simple::Tree object and do a preorder traversal

## create XML::Simple::Tree object from an xml document ($xml_file)
my $xml_obj = XML::Simple::Tree->new(file => directory.xml,
node_key => dir,
target_key => name);

## sub set_do_node() method takes subroutine reference to be executed at current node
$xml_obj->set_do_node(
sub {
my $self = $xml_obj;

my $cnode = $self->get_cnode();
my $level = $self->get_level();
my $padding = * x ($level + 1);

print "$padding$cnode->{name}[0]n";
}
);

## sub set_do_leaf() method takes subroutine reference to be executed at leaf node
$xml_obj->set_do_leaf(
sub {
my $self = $xml_obj;

print "n";
}
);

## Tree pre order traversal method that executes do_node() at each node and do_leaf() at each leaf
$xml_obj->traverse();


## script 2
## find a node and retrieve a parameter.

my $xml_obj =
XML::Simple::Tree->new(
file => $xml_file,
node_key => directory,
target_key => name
);

my $want_node = $xmlObj->find_node($target_directory);
my $mtime = $want_node->{mtime}[0];

## script 3
## find a node and cut (remove) it from tree.

my $cut_name = bin;

my $mainXml =
XML::Simple::Tree->new( file => $xml_file,
node_key => directory,
target_key => name);

$mainXml->cut_node($cut_name);

## script 4
## take XML::Simple::Tree object and paste it into a target node of another
## convert it back to xml

my $target_dir = xxx;

my $cut_tree =
XML::Simple::Tree->new(file => $cut_xml_file,
node_key => directory,
target_key => name);

$config_tree->paste_node($target_dir, $cut_tree->get_cnode()->{directory}[0]);

## convert to xml
my $xml = $config_tree->toXML();

## Additional examples can be found in the included tests.

This module extends XML::Simple by taking the data structure returned by XML::Simple::XMLin($xml_file, forcearray => 1) and putting it in a class complete with tree manipulation and traversal methods. Important to know is that XMLin is called with the option ForceArray => 1. This option forces nested elements to be represented as arrays even when there is only one.