Free weight software for linux

Graph::Weighted is an abstract, weighted graph implementation.

SYNOPSIS

use Graph::Weighted;

$g = Graph::Weighted->new(
data => [
[ 0, 1, 2, 0, 0 ], # A vertex with two edges.
[ 1, 0, 3, 0, 0 ], # "
[ 2, 3, 0, 0, 0 ], # "
[ 0, 0, 1, 0, 0 ], # A vertex with one edge.
[ 0, 0, 0, 0, 0 ] # A vertex with no edges.
]
);

$g = Graph::Weighted->new(
data => {
weight => {
a => { b => 1, c => 2 }, # A vertex with two edges.
b => { a => 1, c => 3 }, # "
c => { a => 2, b => 3 }, # "
d => { c => 1 }, # A vertex with one edge.
e => {} # A vertex with no edges.
}
foo => [
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
],
}
);

$g = Graph::Weighted->new(
data => $Math_Matrix_object,
retrieve_as => ARRAY,
);

$data = $g->weight_data;

$w = $g->graph_weight;

$w = $g->vertex_weight($v1);
$w = $g->vertex_weight($v1, $w + 1);

$w = $g->edge_weight($v1, $v2);
$w = $g->edge_weight($v1, $v2, $w + 1);

$vertices = $g->heaviest_vertices;
$vertices = $g->lightest_vertices;

$w = $g->max_weight; # Weight of the largest vertices.
$w = $g->min_weight; # Weight of the smallest vertices.

# Call the weight methods of the inherited Graph module.
$x = $g->MST_Kruskal;
$x = $g->APSP_Floyd_Warshall;
$x = $g->MST_Prim($p);

Bio::NEXUS::WeightSet is a Perl module that represents column weights in alignment ( for each character).

SYNOPSIS

new Bio::NEXUS::WeightSet($name, @weights, $iswt);

A module representing column weights in alignment (for each character)

METHODS

new

Title : new
Usage : $node = new Bio::NEXUS::WeightSet($name, @weights);
Function: Creates a new Bio::NEXUS::WeightSet object
Returns : Bio::NEXUS::WeightSet object
Args : none

set_weights

Title : set_weights
Usage : $weight->set_weights(@weights);
Function: stores it in the list weights
Returns : none
Args : list of weights

get_weights

Title : get_weights
Usage : @wts=@{$weightset->get_weights()};
Function: Returns the weights array
Returns : reference to array containing weights
Args : none

select_weights

Title : select_weights
Usage : $set->select_weights($columns);
Function: select a subset of characters
Returns : new self with subset of weights
Args : column numbers

is_wt

Title : is_wt
Usage : croak unless $weight->is_wt();
Function: Returns if object has weights (1 yes, 0 no)
Returns : weight existence (integer)
Args : none

set_name

Title : set_name
Usage : $weight->set_name($name);
Function: Sets the name of the weightset
Returns : none
Args : name (string)

get_name

Title : get_name
Usage : $name=$weight->get_name();
Function: Returns the name of the weightset
Returns : name (string)
Args : none

equals

Name : equals
Usage : $set->equals($another);
Function: compare if two WeightSet objects are equal
Returns : boolean
Args : an WeightSet object

UMLet project is an open-source Java tool for rapidly drawing UML diagrams with a pop-up-free, light-weight user interface.
UMLet lets you draw diagram sketches fast; export diagrams to eps, pdf, jpg, svg, and sys.
Add elements to a diagram with a double click. Edit elements using the lower-right text panel. Select multiple elements using Ctrl or lasso. Press C to copy diagram to the system clipboard
Main features:
- fast
- text-based sequence diagram
- call from command line.

bitmask project is a light-weight and fast 2D collision detection library.
The bitmask library provides pixel-perfect collision detection for use in games and other applications. Functions are provided for building bitmasks and testing them for intersection.
The routines can optionally provide a point of intersection and the number of overlapping pixels. The library aims for high performance and portability; it is written in ANSI C and is completely independent of the underlying graphics implementation.
Enhancements:
- Bugfix for bitmask_draw.
- Better testcases.
- Small performance improvements.

ChaNT is a flexible, powerful, cross-browser and easy to use open source web-based chat system written in PHP and JavaScript. Support for BBCode, 3D Animated Smileys with a IM like toolbar for formatting your chat messages. This project does not require any browser plugins like Java or Flash. Also it not requires MySQL, all data stored in ordinary files.

ChaNT included privacy features such as traffic encryption(client-server-client) and client side password hashing. It have powerful admin control panel and can integrated with many forums and CMS. ChaNT supports all major browsers such as Internet Explorer, Firefox, Opera, Safari and Mozilla. It has a minimalistic and an elegant user interface which looks and feels a lot like a IM desktop application, since it uses AJAX. ChaNT is very fast, light weight and makes chatting more fun.

You can bookmark this page and return at any time to find the latest ChaNT updates as they`re released.

How does it work?

The ChaNT client side functioning on JavaScript XMLHttpRequest object to asynchronously communicate with the server-side. Server response parsed and used to update the chat window content. By generating the HTML locally within the browser, and only bringing down JavaScript calls and the actual data, AJAX web pages can appear to load relatively quickly since the payload coming down is much smaller in size.

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");

IQ has been my pet project since September 2003. IQ is an intelligent, modular IRC robot written in PHP. I wrote the original branch, 0.1.x, back in late 2003, and developed it and modules for it until early 2004. At some point in June 2004, I became inspired to rewrite the bots core and start the 0.9.x branch.
The new (0.9.x) branch of IQ is just about an entire rewrite of the original, with better coding techniques, and usage of object oriented PHP. Bugs from the original have been corrected, and dozens of new features have been added. My goal with IQ is to create a truly multi-purpose IRC bot that may be easily coded for, while keeping the core relatively light-weight.
IQ is built from modules and can dynamically load and unload modules. Writing modules for the bot is simple, and any PHP developer should be able to write his or her own modules to have the bot act as needed. Modules utilize a binding system (modeled after that used by eggdrop), which create triggers that can be executed upon any regular event (msg, join, kick, nick, quit, part, etc), as well as other bot-specific events (idle, connect, disconnect), and call lambda-style functions in the module to perform the desired actions.
Enhancements:
- Fixed case-sensitivity issues with dancer ircd
- Improved mode checking for non-hybrid ircds
- Miscellaneous bug fixes and code cleanups
- Added Database class for support for MySQL and pgSQL database servers
- Headlines module removed
- Added currency module
- Added idletime module
- Disallowed running as root

wmjiface is a simple text based network device status monitor.

It shows a weighted average of the traffic for the past several seconds. The average includes the overhead packets.