Free to compute software for linux

List::Compare is a Perl module to compare elements of two or more lists.

SYNOPSIS

The bare essentials:

@Llist = qw(abel abel baker camera delta edward fargo golfer);
@Rlist = qw(baker camera delta delta edward fargo golfer hilton);

$lc = List::Compare->new(@Llist, @Rlist);

@intersection = $lc->get_intersection;
@union = $lc->get_union;

General Comments

List::Compare is an object-oriented implementation of very common Perl code (see "History, References and Development" below) used to determine interesting relationships between two or more lists at a time. A List::Compare object is created and automatically computes the values needed to supply List::Compare methods with appropriate results. In the current implementation List::Compare methods will return new lists containing the items found in any designated list alone (unique), any list other than a designated list (complement), the intersection and union of all lists and so forth. List::Compare also has (a) methods to return Boolean values indicating whether one list is a subset of another and whether any two lists are equivalent to each other (b) methods to pretty-print very simple charts displaying the subset and equivalence relationships among lists.

Except for List::Compares get_bag() method, multiple instances of an element in a given list count only once with respect to computing the intersection, union, etc. of the two lists. In particular, List::Compare considers two lists as equivalent if each element of the first list can be found in the second list and vice versa. Equivalence in this usage takes no note of the frequency with which elements occur in either list or their order within the lists. List::Compare asks the question: Did I see this item in this list at all? Only when you use List::Compare::get_bag() to compute a bag holding the two lists do you ask the question: How many times did this item occur in this list?

Compute Portal Project is a portal project to produce a web based front end to a compute resource, such as a cluster, using PHP, mysql, and apache.
The intent is to allow non-programmers to use complex programs through an intuitive interface.
Enhancements:
- This is the third attempt to create a working release with an install script.
- The last two releases were plagued with copy and paste errors.
- This release is strictly a bugfix release that has been tested in a production environment.
- There may still be residual problems from the 0.8.8 to 0.8.9 transition that included the first install script and moved several directory locations.
- Please give this release a try.

Debt Payoff Calculator is a simple set of PHP (5) scripts that will allow users of a web site to enter their monthly income, monthly budget, and outstanding debts.
The system can then generate a debt payoff report predicting how long it will take to pay off the debts.
The algorithm is:
1. Get total monthly income.
2. Get total monthly expenses.
3. Amount available for debt service is income - expenses;
4. Compute the "kicker" as %20 of Available, reduce available by this amount.
5. Compute the ratio of each debt to total debts.
6. Multiply Available by each ratio to get the potential payment.
7. For the smallest debt, add the kicker.
8. Test if any debts would be paid off
8a. If a debt could be paid off, make the payment, adjust the last debt pointer.
8b. Add any excess funds to the other potentials, using ratio2 which excludes the debt to be paid off.
8b. Repeat 8.
9. Make the remaining payments for debts not paid off.
Repeat 5-9 until all debts paid off.
Print the table of payments.
Enhancements:
- This release has been tested with Internet Explorer and Mozilla as clients.

HPCToolkit is an open-source suite of multi-platform tools for profile-based performance analysis of applications. The figure provides an overview of the toolkit components and their relationships.
Main features:
- hpcrun: a tool for profiling executions of unmodified application binaries using statistical sampling of hardware performance counters.
- hpcprof & xprof: tools for interpeting sample-based execution profiles and relating them back to program source lines.
- bloop: a tool for analyzing application binaries to recover program structure; namely, to identify where loops are present and what program source lines they contain.
- hpcview: a tool for correlating program structure information, multiple sample-based performance profiles, and program source code to produce a performance database.
- hpcviewer: a java-based GUI for exploring databases consisting of performance information correlated with program source.
A program called hpcview is at the toolkits center. It takes performance profiles, program structure information, and, under the direction of a configuration file, correlates it with application source code to produce a browsable performance database.
hpcview also enables the user to define expressions to compute derived metrics as functions other metrics already defined (e.g. measured metrics read from data files or previously-computed derived metrics).
Performance databases are explored using our Java-based hpcviewer user interface that enables one to explore an applications performance data in a top-down fashion and enables one to easily navigate back and forth between performance data and source code.
The user interface presents performance data in a hierarchical display. At any time, you are looking at some program context (program, file, procedure, loop, or line). Also displayed is the data for both the parent and the children of the current context. Up and down arrows on the lines of the display are used to walk the hierarchy.
In order to speed up top-down analysis, the interface also provides `flatten and `un-flatten buttons. Their icons hint at their function. `Flatten modifies the hierarchy by eliding non-leaf children of the current node and replacing them with the grandchildren.
Unflatten reverses this. Since the tables are sorted, the flatten operation makes short work of diving into the program from the top to identify the most important files, procedures, loops and statements.
Performance data manipulated by hpcview can come from any source, as long as the profile data can be translated or saved directly to a standard, profile-like input format. To date, the principal sources of input data for hpcview have been hardware performance counter profiles.
Such profiles are generated by setting up a hardware counter to monitor events of interest (e.g., primary cache misses), to generate a trap when the counter overflows, and then to histogram the program counter values at which these traps occur. For Linux, we developed the hpcrun tool to collect profiles by sampling hardware performance counters.
This tool uses UTKs PAPI library for access to hardware performance counters. A second tool, hpcprof is used to map profiles collected using hpcrun back to program source lines. hpcprof is based on code from Curt Janssens cprof/vprof profiler. On operating systems other than Linux, we use vendor-supplied tools to collect profile data. On MIPS+Irix platforms, we use SGIs ssrun tool to collect profiles. On Alpha+Tru64, we use either with Compaqs uprofile or DCPI utilities for this purpose.
hpcview and hpcviewer can be used to view profile-like data of any type, not just data sampled from hardware performance counters. To analyze one program that contained many register spills, we built a perl script to examine assembly code generated by the SGI compilers for MIPS+Irix and create profiles that map register spills back to source code lines.
To facilitate automation, the programs in HPCToolkit are intended to be run using scripts and configuration files. Once these are set up, rerunning the program to collect new data, and all of the steps that go into generating a browsable dataset can be completely automated. The scripts automate the collection of data and conversion of profile data into a common, XML-based format.
Other performance tools (e.g. SGIs ssrun) report performance data at the line, procedure, and program level. However, since much of the time in scientific programs is spent in loops; having data at the loop level as well is critical to facilitate performance tuning.
For this reason, HPCToolkit includes a binary analyzer bloop that extracts loop nesting structure from application binaries and uses symbol table line map information to map this structure back to the source programs level. Because bloop works on binaries, this process is independent of the language used (though in practice it can be somewhat compiler dependent).
The loop nesting structure information produced by bloop enables hpcview to associate performance data with each loop in a program without incurring any additional overhead for data collection during program execution.
Supported platforms: Pentium+Linux, Opteron+Linux, Athlon+Linux, Itanium+Linux, Alpha+Tru64 and MIPS+Irix.
HPCToolkit is open-source software released with a BSD-like license.

CAM::PDF::GS::NoText is a PDF graphic state.

SYNOPSIS

use CAM::PDF;
my $pdf = CAM::PDF->new($filename);
my $contentTree = $pdf->getPageContentTree(4);
my $gs = $contentTree->computeGS(1);

This class is used to represent the graphic state at a point in the rendering flow of a PDF page. This does not include the graphics state for text blocks. That functionality is in the subclass, CAM::PDF::GS.

FUNCTIONS

$pkg->new($hashref)

Create a new instance, setting all state values to their defaults. Stores a reference to $hashref and sets the property $hashref-{fm}> to undef.
$self->clone()

Duplicate the instance.

CONVERSION FUNCTIONS

$self->applyMatrix($m1, $m2)

Apply $m1 to $m2, save in $m2.

$self->dot($matrix, $x, $y)

Compute the dot product of a position against the coordinate matrix.

$self->userToDevice($x, $y)

Convert user coordinates to device coordinates.

$self->getCoords($node)

Computes device coordinates for the specified node. This implementation handles line-drawing nodes.

$self->nodeType($node)

Returns one of block, path, paint, text or (the fallback case) op for the type of the specified node.

Coinflip provides a cryptographically secure server/client program and protocol for choosing random bits.

Coinflip is a client/server based program that can generate random bits for 2 people over the internet. The 2 people dont have to trust each other in order to convince each other that the bit is truly a random bit.

Its called coinflip, of course, because flipping a coin in the real world is the equivalent of generating a random bit on a computer. (Its either heads or tails. Its either a 1 or a 0.)

Coinflip uses a slightly modified version of the "Coin Flipping Using One-Way
Functions" protocol outlined in Bruce Schneiers Applied Cryptography 2nd
edition.

This attack would work everytime Alice acted as the server in a coinflip procedure, providing Bob never realized that Alice was sending him the same y value every time. Or she could us it to trick multiple Bobs.

While it is supposed to be computationally infeasible to compute collisions in one-way hash functions, recent papers suggest that if you have enough money and time, collisions can be precalculated. P. van Oorschot and M. Wiener in their paper, "Parallel collision search with application to hash functions and discreet logarithms", estimate that for $10 million (in 1994 US dollars), a collision could be found for MD5 in 24 days on average. (Thanks for the info, defrost).

The solution is actually quite simple: Have both parties choose part of the random data, and use whatever size random number you like. Since Bob is expecting to see x contain his random data, Alices collision attack is nullified, and since Alice gets to put in her own data, she can make Bobs array attack infeasible.

crosssum project is a puzzle game to design and play cross sum games.

A cross sum puzzle is similar to a cross word puzzle, only the clues are the sums of sequences of single-digit numbers.

When in playing mode, you change the numbers by clicking on the square you wish to change. The number for the square is dependent on the position in the square that you click. Verifying play mode is identical to play except erroneous answers are highlighted.

In desiging mode you can change a square from an answer square to a blank square by clicking on it. One click toggles it. When you finished designing, use ^r to compute a puzzle for the board Squares are mirrored, if you want to override this press CTRL
while you click

The rules are:
1. Sums must be formed from strings of [1,9] with no dups
2. The grey squares are the answers, numbers above the diagonal are the answers for the sum to the right numbers below the diagonal are the answers for the sum below.

froofyJIT is a C++ syntactic sugar front-end for Paolo Bonzinis GNU lightning library for dynamic native code generation. froofyJIT program uses C++s powerful language facilities to allow GNU lightning instructions to be expressed in a more concise way that approximates a real assembly language.
Below is a program which uses froofyJIT to compute a Fibonacci number (directly translated from tests/fib.c in GNU lightning):
#include < cstdlib >
#include < iostream >
#include "froofy/jit.h"
static jit_insn codeBuffer[1024];
typedef int (*pifi)(int);
int main()
{
pifi nfibs;
int in;
{
using namespace froofy::jit;
label< > basis;
nfibs/ !org, codeBuffer;
prolog, 1;
!arg< ui > in;
getarg< ui > v0, in;
blti< ui > basis, v0, 2;
subi< ui > v1, v0, 1;
subi< ui > v2, v0, 2;
prepare< i > 1;
pusharg< ui > v1;
finish, nfibs;
retval< i > v1;
prepare< i > 1;
pusharg< ui > v2;
finish, nfibs;
retval< i > v2;
addi< ui > v1, v1, 1;
addr< ui > rr, v1, v2;
ret --;
basis/ movi< i > rr, 1;
ret --;
!end, codeBuffer;
}
std::cout<<less