Free binary system software for linux

System-CoW is a system monitoring SuperKaramba theme.

You must have installed hddtemp and all i2c sensors in kernel to have this script working!

You must launch:

hddtemp -d /dev/hd[abc] // if you have 3 disks!

to have temperature working!

For gentoo add a line to /etc/conf.d/local.start to load the command line at startup!

My Own Building System (a.k.a. mobs) is a GPLd build system, lightweight and easy to use, with a limited application framework. My Own Building System project gets information from the end-user wanting to build your project and modifies the building process according to such information.

It provides the developer with some development helpers, including some makefile framework and an interface for the end-user (the 0 script). This building system supports the (more or less) automatic building of C, C++, Bison/Yacc, Flex/Lex, and Texinfo source files, and the creation of static and shared libraries and binaries.

It is not a GNU autoconf/automake clone, and although the command line of the 0 script certainly mimics the one of GNU configure it is only for the sake of end-users. Internally, and from the point of view of the developer, is very different.

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.

Nelisys project is Open Source Web-based Management System, to manage and monitor system and network including Router, Switch, Wi-Fi Access Point, Server, Networking services, etc.

There are performance and fault management function.

Search::Binary is a Perl module for generic binary search.

SYNOPSIS

use Seach::Binary;
$pos = binary_search($min, $max, $val, $read, $handle, [$size]);

binary_search implements a generic binary search algorithm returning the position of the first record whose index value is greater than or equal to $val. The search routine does not define any of the terms position, record or index value, but leaves their interpretation and implementation to the user supplied function &$read(). The only restriction is that positions must be integer scalars.

During the search the read function will be called with three arguments: the input parameters $handle and $val, and a position. If the position is not undef, the read function should read the first whole record starting at or after the position; otherwise, the read function should read the record immediately following the last record it read. The search algorithm will guarantee that the first call to the read function will not be with a position of undef. The read function needs to return a two element array consisting of the result of comparing $val with the index value of the read record and the position of the read record. The comparison value must be positive if $val is strictly greater than the index value of the read record, 0 if equal, and negative if strictly less. Furthermore, the returned position value must be greater than or equal to the position the read function was called with.

The input parameters $min and $max are positions and represents the extent of the search. Only records which begin at positions within this range (inclusive) will be searched. Moreover, $min must be the starting position of a record. If present $size is a difference between positions and determines when the algorithms switches to a sequential search. $val is an index value. The value of $handle is of no consequence to the binary search algorithm; it is merely passed as a convenience to the read function.

Tree::Binary::Search is a binary search tree for Perl.

SYNOPSIS

use Tree::Binary::Search;

my $btree = Tree::Binary::Search->new();

$btree->useNumericComparison();

$btree->insert(5 => "Five");
$btree->insert(2 => "Two");
$btree->insert(1 => "One");
$btree->insert(3 => "Three");
$btree->insert(4 => "Four");
$btree->insert(9 => "Nine");
$btree->insert(8 => "Eight");
$btree->insert(6 => "Six");
$btree->insert(7 => "Seven");

# this creates the following tree:
#
# +-------(5)----------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +----(8)
# | |
# (4) (6)-+
# |
# (7)
#

$btree->exists(7); # return true

$btree->update(7 => "Seven (updated)");

$btree->select(9); # return Nine

$btree->min_key(); # returns 1

$btree->min(); # returns One

$btree->max_key(); # return 9

$btree->max(); # return Nine

$btree->delete(5);

# this results in the following tree:
#
# +-------(6)-------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +-(8)
# | |
# (4) (7)
#

This module implements a binary search tree, which is a specialized usage of a binary tree. The basic principle is that all elements to the left are less than the root, all elements to the right are greater than the root. This reduces the search time for elements in the tree, by halving the number of nodes that need to be searched each time a node is examined.

Binary search trees are a very well understood data-structure and there is a wealth of information on the web about them.

Trees are a naturally recursive data-structure, and therefore, tend to lend themselves well to recursive traversal functions. I however, have chosen to implement the tree traversal in this module without using recursive subroutines. This is partially a performance descision, even though perl can handle theoreticaly unlimited recursion, subroutine calls to have some overhead. My algorithm is still recursive, I have just chosen to keep it within a single subroutine.