Free weighted 0.1301 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);

subPersistence is an abstract, light-weight yet flexible framework for working with O/R persistence mappers. It provides for independence of a specific O/R mapper such as Hibernate or Castor.
While you can use Hibernate or Castor (or other O/R mappers) directly, coupling your application too tightly to those can be a bad thing. subPersistence makes it easy to switch underlying O/R mappers, thereby decoupling the application layer from those.
It abstracts away differences between the mappers, while still making it possible to use their specific features if needed.
Enhancements:
- This version updates to Java 5 features such as Generics and is the first version to require Hibernate 3.

Pen is a load balancer for "simple" TCP-based protocols such as HTTP or SMTP. Pen project allows several servers to appear as one to the outside.
It automatically detects servers that are down and distributes clients among the available servers. This gives high availability and scalable performance.
The load balancing algorithm keeps track of clients and will try to send them back to the server they visited the last time. The client table has a number of slots (default 2048, settable through command-line arguments). When the table is full, the least recently used one will be thrown out to make room for the new one.
This is superior to a simple round-robin algorithm, which sends a client that connects repeatedly to different servers. Doing so breaks applications that maintain state between connections in the server, including most modern web applications.
When pen detects that a server is unavailable, it scans for another starting with the server after the most recently used one. That way we get load balancing and "fair" failover for free.
Correctly configured, pen can ensure that a server farm is always available, even when individual servers are brought down for maintenance or reconfiguration. The final single point of failure, pen itself, can be eliminated by running pen on several servers, using vrrp to decide which is active.
Enhancements:
- This release fixes a bug in the weighted server selection: server_by_weight would never consider blacklisted servers, which kept them blacklisted indefinitely.

Watsup is a system and process monitor for CPU, memory, page faults, disk IO, network IO.
Low overhead. GUI controls. Formatted report in window. Sample interval down to 0.1 secs. Choose font size. System resources: CPU (1-4), memory (free/used/cache), page faults (hard/soft), disk IO, network IO. Process resources: same + execution file name.
Main features:
- overhead is about 1/3 as much
- sample interval as low as 0.1 seconds is supported
- overall system and top process resources are shown on one page
- disk I/O, network I/O, and page fault rates can be monitored
- font can be made small (for display in a corner) or large (whole screen)
- the top N processes are displayed with minimal jumping around between samples
- (which makes it easier to watch one or a few processes)
- process ranking is a weighted sum of CPU, hard page faults, and disk I/O

Gecode is a accessible, portable, and efficient environment for developing constraint-based systems and applications.
Gecode is radically open for programming, meaning that it can be easily interfaced to other systems. It supports the programming of new propagators (as implementation of constraints), branching strategies, and search engines.
New variable domains can be programmed at the same level of efficiency as finite domain and integer set variables that come predefined with Gecode.
Main features:
Kernel
- Gecodes kernel provides a comprehensive programming interface to construct new variable domains (including propagators as implementations of constraints and branchings) and search engines. It is slim (around 1000 lines of code) and requires no modification or hacking for adding new variable domains or search engines.
Search
- Search in Gecode is based on recomputation and copying. Advanced techniques include adaptive (speeds up further search) and batch recomputation (drastically reduces propagation during recomputation). Currently, Gecode supports search for some solutions, optimization (branch-and-bound), and limited discrepancy search (more details). Parallel thread-based search is currently under development.
Finite domain constraints
- Gecode comes with finite domain constraints implemented on top of the generic kernel. It offers standard constraints such as arithmetics, Boolean, linear equations, and global constraints such as: distinct (alldifferent, both bounds and domain consistent), global cardinality (both bounds and domain consistent), element, cumulatives, regular, sortedness, and lex. It is simple to add new constraints and branchings (in particular as the complete source code with the above constraints as examples is available).
Finite set constraints
- Gecode also provides finite integer set variables. The standard set relations and operations are available as constraints, plus some specialized constraints such as convexity, global reasoning for distinctness of sets, selection constraints, weighted sets, and constraints connecting finite domain and finite set variables. As for the finite domain constraints, the library can be easily extended with new constraints and branchings.
Basic modeling support
- Even though Gecode has been designed to be easy to interface to and not to be easy to model with, it comes with some basic modeling support. This supports expressing linear and Boolean constraints in the standard way as expressions build from numbers and operators.
Enhancements:
- This is a minor release which fixes a major bug that appears when using branch-and-bound search.

XkbInd stands for X Keyboard Extension Indicator and is a small, simple, but useful indicator of keyboard layout (XKB group) for the X Window System.
It indicates the current keyboard layout in the title of top-level windows via a prefix to the original string.
XkbInd allows the user to simulate independent keyboard layout for each handled window, and it works with most window managers, including twm, mwm, and fvwm.
Main features:
- XkbInd simulates an independent keyboard layout for each handled top-level window.
- XkbInd is very light-weighted and uses less than 150 kb of virtual memory (excluding "shared" of course).
- XkbInd doesnt grab entries in default color pallet, doesnt perform any drawing operations itself, but relies wholly to the window manager.
- XkbInd doesnt occupy any area on the screen, and outputs all relevant information to window titles.
- XkbInd can be configured to ignore (or accept) particular windows or applications. This feature is based on examination of WM_CLASS property. It is possible to use shell type wildcards in "accept" and "ignore" lists.
- XkbInd is "true" XKB program, i.e. all interactions with X-server are carried out through the XKB extension protocol.
- XkbInd keeps all information about current keyboard layout of each handled window at server side in form of window properties unlike most of the other similar programs which keep this data in local storage.
- And the last, XkbInd does only what it says--it is an indicator. Nothing more.
To compile and install XkbInd you should perform the following:
# cd xkbind-
# ./configure
# make
# make install

GRZipII project is a high-performance file compressor based on Burrows-Wheeler Transform, Schindler Transform, Move-To-Front and Weighted Frequency Counting.
GRZipII uses The Block-Sorting Lossless Data Compression Algorithm, which has received considerable attention over recent years for both its simplicity and effectiveness.
This implementation has compression rate of 2.234 bps on the Calgary Corpus(14 files) without preprocessing filters.
NOTE: GRZipII cant compress/uncompress pkzip/winzip files (*.zip).
Usage: GRZipII < e|d > InputFile OutputFile < Switches >
< Switches >
-b< size > Maximum block size(e.g. -b1m, -b1024k)
(default -b5m or -b5120k, maximum -b8m)
-m< mode > Compression algorithms, default: -m1
-m1 LZP + BWT + WFC + EC
-m2 LZP + BWT + MTF + EC
-m3 LZP + ST4 + WFC + EC
-m4 LZP + ST4 + MTF + EC
-a Enable Adaptive block size reduction
-l Disable LZP preprocessing
-p Disable all Preprocessing techniques
-h Show all Switches
Enhancements:
- The grzip package now includes additional scripts such as grzcat, grzless, and grzdiff.
- Other minor corrections and enhancements have been made.

Acme::Playmate is a Perl module to consult the playboy playmate directory for playmate information.

SYNOPSIS

use Acme::Playmate;

my $playmate = new Acme::Playmate("2003", "04");

print "Details for playmate " . $playmate->{ "Name" } . "n";
print "Birthdate" . $playmate->{ "BirthDate" } . "n";
print "Birthplace" . $playmate->{ "BirthPlace" } . "n";
print "Bust" . $playmate->{ "Bust" } . "n";
print "Waist" . $playmate->{ "Waist" } . "n";
print "Hips" . $playmate->{ "Hips" } . "n";
print "Height" . $playmate->{ "Height" } . "n";
print "Weight" . $playmate->{ "Weight" } . "n";