Free total drama island software for linux

Set::IntSpan::Island is a Perl extension for Set::IntSpan to handle islands and covers.

SYNOPSIS

use Set::IntSpan::Island

# inherits normal behaviour from Set::IntSpan
$set = Set::IntSpan::Island->new( $set_spec );
# special two-value input creates a range a-b
$set = Set::IntSpan::Island->new( $a,$b );

# equivalent to $set->cardinality($another_set)->size;
if ($set->overlap( $another_set )) { ... }

# negative if overlap, positive if no overlap
$distance = $set->distance( $another_set );

# remove islands shorter than $minlength
$set = $set->remove_short( $minlength );

# fill holes up to $maxholesize
$set = $set->fill( $maxholesize );

# return a set composed of islands of $set that overlap $another_set
$set = $set->find_island( $another_set );

# return a set comopsed of the nearest non-overlapping island(s) to $another_set
$set = $set->nearest_island( $another_set );

# construct a list of covers by exhaustively intersecting all sets
@covers = Set::IntSpan::Island->extract_cover( { id1=>$set1, id2=>set2, ... } );
for $cover (@covers) {
($coverset,@ids) = ($cover->[0], @{$cover->[1]});
print "cover",$coverset->run_list,"contains sets",join(",",@ids);
}

This module extends the Set::IntSpan module by Steve McDougall. It implementing methods that are specific to islands and covers. Set::IntSpan::Island inherits from Set::IntSpan.

Terminology

An integer set, as represented by Set::IntSpan, is a collection of islands (or spans) on the integer line

...-----xxxx----xxxxxxxx---xxxxxxxx---xx---x----....

Islands are disjoint and contiguous, by definition, and may be represented by their own Set::IntSpan object. Regions not in the set that fall between adjacent spans are termed holes. For example, the integer set above is composed of 5 islands and 4 holes. The two infinite regions on either side of the set are not counted as holes within the context of this module.

METHODS

$set = Set::IntSpan::Island->new( $set_spec )

Constructs a set using the set specification as supported by Set::IntSpan.

$set = Set::IntSpan::Island->new( $a, $b )

Extension to Set::IntSpan new method, this double-argument version creates a set formed by the range a-b. This is equivalent to

$set = Set::IntSpan::Island->new("$a-$b")

but permits initialization from a list instead of a string.

$set_copy = $set->duplicate()

Creates a copy of $set.

$overlap_amount = $set->overlap( $another_set );

Returns the size of intersection of two sets. Equivalent to

$set->intersect( $another_set )->size;

$d = $set->distance( $another_set )

Returns the distance between sets, measured as follows. If the sets overlap, then the distance is negative and given by

$d = - $set->overlap( $another_set )

If the sets do not overlap, $d is positive and given by the distance on the integer line between the two closest islands of the sets.

$d = $set->sets()

Returns all spans in $set as Set::IntSpan::Island objects. This method overrides the sets method in Set::IntSpan in order to return sets as Set::IntSpan::Island objects.

$set = $set->excise( $minlength )

Removes all islands within $set smaller than $minlength.

$set = $set->fill( $maxlength )

Fills in all holes in $set smaller than $maxlength.

$set = $set->find_islands( $integer )

Returns a set containing the island in $set containing $integer. If $integer is not in $set, an empty set is returned.

$set = $set->find_islands( $another_set )

Returns a set containing all islands in $set intersecting $another_set. If $set and $another_set have an empty intersection, an empty set is returned.

$set = $set->nearest_island( $integer )

Returns the nearest island(s) in $set that contains, but does not overlap with, $integer. If $integer lies exactly between two islands, then the returned set contains these two islands.

$set = $set->nearest_island( $another_set );

Returns the nearest island(s) in $set that intersects, but does not overlap with, $another_set. If $another_set lies exactly between two islands, then the returned set contains these two islands.

$cover_data = Set::IntSpan::Island->extract_covers( $set_hash_ref )

Given a $set_hash reference

{ id1=>$set1, id2=>$set2, ..., idn=>$setn}

where $setj is a finite Set::IntSpan::Island object and idj is a unique key, extract_covers performs an exhaustive intersection of all sets and returns a list of all covers and set memberships. For example, given the id/runlist combination

a 10-15
b 12
c 14-20
d 25

The covers are

10-11 a
12 a b
13 a
14-15 a c
16-20 c
21-24 -
25 d

The cover data is returned as an array reference and its structure is

[ [ $cover_set1, [ id11, id12, id13, ... ] ],
[ $cover_set2, [ id21, id22, id23, ... ] ],
...
]

If a cover contains no elements, then its entry is

[ $cover_set, [ ] ]

$island = $set->num_islands

Returns the number of islands in the set.

$island = $set->at_island( $island_index )

Returns the island indexed by $island_index. Islands are 0-indexed. For a set with N islands, the first island (ordered left-to-right) has index 0 and the last island has index N-1.

If $island_index is negative, counting is done back from the last island (c.f. negative indexes of Perl arrays).

$island = $set->first_island

Returns the first island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the first island.

If the set is empty, returns undef.

$island = $set->last_island

Returns the last island of the set as a Set::IntSpan::Island object. As a side-effect, sets the iterator to the last island.
If the set is empty, returns undef.

$island = $set->next_island

Advances the iterator forward by one island, and returns the next island. If the iterator is undefined (e.g. not previously set by first()), the first island is returned.
Returns undef if the set is empty or if no more islands are available.

$island = $set->prev_island

Reverses the iterator backward by one island, and returns the previous island. If the iterator is undefined (e.g. not previously set by last()), the last island is returned.

Returns undef if the set is empty or if no more islands are available.

$island = $set->current_island

Returns the island at the current iterator position.

Returns undef if the set is empty or if the iterator is not defined.

TEA Total is a very small 128 bit private key based encryption/decryption system which uses the block variant of TEA (Tiny Encryption Algorithm).

TEA is said to be several times faster than DES, as well as being much smaller and possibly more secure. It also isnt encumbered by any patents and the reference implementation is in the public domain.

Currently TEA Total only supports encryption and decryption of files (with optional compression and/or Base64 ASCII encoding). I am writing a set of TEA based encrypted tunnel programs which will allow you to wrap applications such that their input and output will be transparently forwarded over a network in encrypted form.

About the name: TEA Total is a play on the TEA encryption algorithm which is at the heart of the package, and the phrase "tee total"; a term used to refer to a person who does not drink alcohol. This is appropriate because I am tee total myself.

To build TEA Total in a Unix type environment, edit config.inc to select the options you want to build, your install prefix, and your architecture type, then type make. Check that the compares succeed, then run make install (possibly as root).

After it builds, it will run through a set of self tests. Read the output carefully to make sure that they have all passed.

Note that the Makefile uses some GNU-Makeisms, so on systems which have pmake or something else by default, you may have to install gnu make instead and run it with "gmake".

If you are building on a currently unsupported architecture type, you will need to add a new architecture type description to config.inc and arch.h.

The program can be installed using "make install".

Stormbaan Coureur is a simulated obstacle course for automobiles. n this game, your objective is to drive your car along an obstacle course. Success depends on total control of the car, and making use of the laws of physics.
Enhancements:
- New name
- Extended track with half pipe jump
- Extended track with turn tables
- Fixed joystick accelerator axis assigment
- Softened the suspension
- Added brake-light
- Added reverse-gear-light
- Improved leaderboard
- Added respawn points

Create your own Viking chieftain (or chieftess), sail on quests to foreign places, challenge other online players to battle and then go spend your loot on more Viking gear!

Enhancements:

• Number of players on each island shown on the Hall map.
• Players can create their own rooms in the Hall.
• The Lur Blaster will no longer lose energy if he is stunned while playing a tune.
• Initial cease-fire period reduced in treasure games to avoid tower axemen rushing.

Requirements: Java 2 Standard Edition Runtime Environment

Debian Installed Package Information shows the current debian installed packages with the ability to explore and show the contents, shows the stats and description of the suggested and recommended packages and also the policy and changelogs.
Debian Installed Package Information try to find screenshots of the suggested and recommended packages.
Enhancements:
- Added Screenshots for Suggested and Recommended packages
- Added Info about total packages Installed
- Added Version of Suggested and Recommended packages
- Miscelaneous dessign graphic changes
- Bug finding Suggested and Recommended packages installed solved.
- Add fast search package functions.

Agata Report is a cross-platform database reporting tool with graph generation and a query tool that allows you to get data from PostgreSQL, MySQL, SQLite, Oracle, DB2, MS-SQL, Informix, InterBase, Sybase, or Frontbase and export that data as PostScript, plain text, HTML, XML, PDF, or spreadsheet (CSV) formats through its graphical interface.

You can also define subtotals, levels and a grand total for the report, merge the data into a document, generate address labels, or even generate a complete ER-diagram from your database.

Contrast Autostretch is a simple plug-in does an automatic contrast stretch. For each channel in the image, it finds the minimum and maximum values, and uses that information to stretch the individual channels histograms to the full contrast range.

For some images it may do just what you want; for others it may be total crap. If the latter, you may want to consider using the Normalize plug-in by Adam Moss.