Free n software for linux

N:aRC is comes from Necs Amarok Remote Control and is a shell script, which allows the (remote) controlling of amarok per ssh.
It is mainly a wrapper for the amarok DCOP functions, but also simplifies the ssh process.
It is possible to run it with keyboard shortcuts.
Usage: $0 [Options] < Command >
--help, -h Prints this help message
--version, -v Prints the version information
Options could be one or more of the following:
--host, -H Sets the host to connect to
--user, -u Sets the user as which to connect
< user >@< host > Same as "-H < host > -u < user >"
--remove, -r Removes the authorization file afterwards
--append, -a Append the authorization file to the existing one and do not replace it
Command could be one of the following:
add < DIR > Adds DIR to current playlist
create < DIR > Creates new playlist from DIR
play, p (Re)starts playing
pause, p Pauses playing
stop, s Stops playing
stopafter, f Stops after current song
next, n Goes to next item in playlist
prev, e Goes to previous item in playlist
current, c Prints currently playing song
random, r < on/off > Sets random mode on/off
volume, v < X > Sets volume to X %
volumeup, vu [n] Increases volume by n reasonable steps. (n defaults to 1)
volumedown, vd [n] Decreases volume by n reasonable steps. (n defaults to 1)
Enhancements:
- This release adds a new command line option that is useful with keyboard shortcuts.

n-genes is a powerful Genetic Algorithms and Programming toolkit written for Java 5.
Using advanced object oriented techniques, like generics and introspection, it is one the simplest system to learn and use. N-geness design allows fast coding and a total flexibility.
n-genes is an open-source project released under GPL. It is free of charges.
Main features:
Stack-based Genetic Programming
The Genetic Programming implemented in n-genes relies on a linear postfix programs, close to Forth or Postscript programming languages. They allow the following advantages:
- High-level and turing-complete language (through flow-control instructions);
- Extendable and customisable instruction set;
- Possibility of using faster and simpler GA operators;
- Efficient bloat removing/controlling algorithms.
Modularity and Dynamic Config Files
All parts of evolutionary computing have been made components, through " Design Patterns" methodology. The benefits are:
- Separation of the behaviour from the representation, i.e. we can use the same operators for a GA doubles individual or for a GP problem;
- Short and readable code, since each object represents only a single operation and therfore has few and shorts methods.
- The possibility to change the components or their behaviour during evolution, for example changing dynamically the size of a population or using self-adaptating mutation operators.
The n-genes platform is coupled with a dynamic config file system. This system is able to instanciate whatever class, passing arbitrary parameters of whaterver types, whithout needing to extend the parser. Object introspection is used at initialisation.
Performances Optimisations
n-genes was written with high performance computing in mind. Here are the optimisations you get for free, using our platform:
- Object-recycling memory management, eliminating the time spent on objects allocation and garbage-collections;
- Efficient individual-level fitness cache, the fitness is lazy-computed and cached until the individual is mutated;
- Population-level individual cache, saving computation time when the population diversity dimish.

N:PyTpl comes from Necs Python Template System and is a template script written in Python.
It parses template files and creates e.g. HTML as output. Therefore, it is ideal to use for HTML pages, because it reduces redundancy to an absolute minimum.
Templates
Files
- file extension: .tpl
Comments
- comments start with a hash # - only a full line can be commented out
Tags
- tags are written in-between square brackets and have to take a whole line: [Tag]
- whitespaces in front of a tag are allowed
- everything following a tag is called "the arguments"; every single line is one argument
- TAG(arg1,arg2) shows the definition above
- Names of tags:
+ can held every char - umlauts should be avoided
+ should not start with a dollar sign $ - these are handled by the system (differently)
+ should not consist of special characters
- in generally, newlines (n) are deleted from the arguments - these can be prevented by an exclamation mark ! at the end of the tag: [Tag!]
- if an option-tag should be disabled (e.g. $PARENTS_LINK), a question mark ? is used at the end of name: [Tag?] - alternatively you can state "NOT" as the argument
- should a tag be stated as a constant (ie. it isnt looked up during loops), append an equation sign = to the name of the tag: [Tag=]
- it is not possible to set multiple flags in one tag
- if arguments are given w/o a tag, they are said to belong to the tag $MAIN (q.v.)
Taggys
- taggys are these expressions, which are replaced by the arguments of the tag later on
- they are written in double curly braces: {{Taggy}}
- names of taggys:
+ _must_ have the same name as the corresponding tag
+ ==> same restrictions
- if a taggy cannnot be replaced, the whole argument is removed - this can be avoided by a terminating excl. mark: {{Taggy!}} - in this case the output will show {{Taggy}}
- if a taggy should not be processed during a loop, add an equation sign to the end: {{Taggy=}}
Enhancements:
- Increased loop performance, a new loop type, and standard templates directly in the source.

Tilt-n-Roll is a puzzle game where you must roll your marble through the 3d maze to the exit.
This game is an entry into Intels Game Demo 2007 contest. Please take the time to rate my game and help me win a prize!
Tilt the 3d maze and roll your marble to the exit. The final version will fully support laptop SMS / HDAPS sensors to allow players to tilt the laptop to play! (Support is partially there now - Linux users get an SDL patch and Mac users can wrangle with Unimotion).
Main features:
- Multiple powerups, monsters, switches, puzzles, traps...
- Built-in level editor: design and share your mazes with friends!
- Keyboard or mouse control for unsupported laptops
- Plenty of sound effects and catchy music
- Physics calculations are run in a second thread: multicore users should see an increase in both framerate and simulation accuracy
- Runs on Windows, Mac OS or Linux.
- Completely open-source software under the GNU GPL!

Env::Bash is a Perl extension for accessing _all_ bash environment variables.

SYNOPSIS

use Env::Bash;

Standard interface:

my @var = get_env_var( "SORCERER_MIRRORS",
Source => "/etc/sorcery/config", );
print "SORCERER_MIRRORS via get_env_var:n",
join( "n", @var ), "ncount = ", scalar @var, "n";

@var = Env::Bash::SORCERER_MIRRORS
( Source => "/etc/sorcery/config", );
print "SORCERER_MIRRORS via name:n",
join( "n", @var ), "ncount = ", scalar @var, "n";

my @keys = get_env_keys( Source => "/etc/sorcery/config",
SourceOnly => 1, );
print "first 10 keys:n", map { " $_n" } @keys[0..9];
Object oriented interface:
my $be = Env::Bash->new( Source => "/etc/sorcery/config",
Keys => 1, );
my @var = $be->get( "SORCERER_MIRRORS" );
print "SORCERER_MIRRORS via get:n",
join( "n", @var ), "ncount = ", scalar @var, "n";

@var = $be->SORCERER_MIRRORS;
print "SORCERER_MIRRORS via name:n",
join( "n", @var ), "ncount = ", scalar @var, "n";

$be = Env::Bash->new( Keys => 1,);
@var = $be->HOSTTYPE;
print "HOSTTYPE via name:n",
join( "n", @var ), "ncount = ", scalar @var, "n";

if( $be->exists( BASH_VERSINFO ) ) {
print "BASH_VERSINFO =>n ",
join( "n ", $be->BASH_VERSINFO ), "n";
}

my %options = $be->options( [], Keys => 1 );
Tie HASH interface:
my %env = ();
tie %env, "Env::Bash", Source => "/etc/sorcery/config", ForceArray => 1;

my $var = $env{SORCERER_MIRRORS};
print "SORCERER_MIRRORS via tied hash:n",
join( "n", @$var ), "ncount = ", scalar @$var, "n";

$var = $env{HOSTTYPE};
print "HOSTTYPE via tied hash:n",
join( "n", @$var ), "ncount = ", scalar @$var, "n";

while( my( $key, $value ) = each %env ) {
print "$key =>n ", join( "n ", @$value ), "n";
}

Net::iTMS is a Perl interface to the information within the iTunes Music Store (iTMS).

SYNOPSIS

my $iTMS = Net::iTMS->new;

my $artist = $iTMS->get_artist(2893902);
print "Artist: ", $artist->name, "n";

for my $album ($artist->discography) {
print $album->title, "n";

for my $track ($album->tracks) {
print "t ", $track->number, ": ", $track->title, "n";
}
}

Net::iTMS is the main class (that is, the one you should be using) for interacting with Apples iTunes Music Store (http://apple.com/itunes/store/).

Currently, it provides means to access individual artist, album, and song information in the iTMS.

Aw::Admin is a Perl extension for the ActiveWorks C Administration Libraries.

SYNOPSIS

use Aw MyFavoriteBroker@my.host.net:6449;
require Aw::Admin::ServerClient;

my $desc = new Aw::ConnectionDescriptor;

my $server = new Aw::Admin::ServerClient ( "my.host.net:6449", $desc );
#
# fix new to use default host weve already set..
#

my @brokers = $server->getServerBrokers ( );

foreach ( @brokers ) {
print "Territory : $_->{territory_name}n";
print "Broker Host: $_->{broker_host}n";
print "Broker Name: $_->{broker_name}n";
print "Description: $_->{description}n";
}

PDL::Ufunc Perl module contains primitive ufunc operations for pdl.

This module provides some primitive and useful functions defined using PDL::PP based on functionality of what are sometimes called ufuncs (for example NumPY and Mathematica talk about these). It collects all the functions generally used to reduce or accumulate along a dimension. These all do their job across the first dimension but by using the slicing functions you can do it on any dimension.

The PDL::Reduce module provides an alternative interface to many of the functions in this module.

SYNOPSIS

use PDL::Ufunc;

Project via $name to N-1 dimensions

This function reduces the dimensionality of a piddle by one by taking the $name along the 1st dimension.

By using xchg etc. it is possible to use any dimension.

$a = $op($b);
$spectrum = $op $image->xchg(0,1)
$extras
EOD
} # sub: projectdocs()
sub cumuprojectdocs { my $name = shift; my $op = shift; my $extras = shift; return { name => sum, op => +=, init => 0, }, prodover => { name => product, op => *=, init => 1, }, );
foreach my $func ( keys %over ) {

# creates $func and cumu$func functions
# and d$func and dcumu$func functions, which
# perform the calculations in double precision

my $name = $over{$func}{name};
my $op = $over{$func}{op};
my $init = $over{$func}{init};

pp_def(
$func,
HandleBad => 1,
Pars => a(n); int+ [o]b();,
Code =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{ tmp . $op . $a(); %}
$b() = tmp;,
BadCode =>
$GENERIC(b) tmp = . $init . ;
int flag = 0;
loop(n) %{
if ( $ISGOOD(a()) ) { tmp . $op . $a(); flag = 1; }
%}
if ( flag ) { $b() = tmp; }
else { $SETBAD(b()); },
Doc => projectdocs( $name, $func, ),
);

# as above, but in double precision
pp_def(
"d$func",
HandleBad => 1,
Pars => a(n); double [o]b();,
Code =>
double tmp = . $init . ;
loop(n) %{ tmp . $op . $a(); %}
$b() = tmp;,
BadCode =>
double tmp = . $init . ;
int flag = 0;
loop(n) %{
if ( $ISGOOD(a()) ) { tmp . $op . $a(); flag = 1; }
%}
if ( flag ) { $b() = tmp; }
else { $SETBAD(b()); },
Doc => projectdocs( $name, "d$func",
"Unlike L, the calculations are performed in doublen" .
"precision." ),
);

my $cfunc = "cumu${func}";
pp_def(
$cfunc,
HandleBad => 1,
Pars => a(n); int+ [o]b(n);,
Code =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{
tmp . $op . $a();
$b() = tmp;
%},
BadCode =>
$GENERIC(b) tmp = . $init . ;
loop(n) %{
if ( $ISBAD(a()) ) { $SETBAD(b()); }
else {
tmp . $op . $a();
$b() = tmp;
}
%},
Doc => cumuprojectdocs( $name, $cfunc, ),
);

# as above but in double precision
pp_def(
"d$cfunc",
HandleBad => 1,
Pars => a(n); double [o]b(n);,
Code =>
double tmp = . $init . ;
loop(n) %{
tmp . $op . $a();
$b() = tmp;
%},
BadCode =>
double tmp = . $init . ;
loop(n) %{
if ( $ISBAD(a()) ) { $SETBAD(b()); }
else {
tmp . $op . $a();
$b() = tmp;
}
%},
Doc => cumuprojectdocs( $name, $cfunc,
"Unlike L , the calculations are performed in doublen" .
"precision." ),
);