Free to run software for linux

VBox Runner 0.2 provides you with a small but very useful KRunner module which can allow you to run your VirtualBox virtual machines from KRunner. This product will be an excellent choice for everyone.

Robo Hunt is an action game where you have to run for life and plutonium.

Take all plutonium and dont be caught. The robot hunters are smart and they do not cheat.

RUNT (ResNet USB Network Tester) is Slackware Linux designed to run off of a 128 MB USB pen drive. RUNT Linux project consists of a boot floppy image and a zip file, similar to zipslack.

It is intended to be a fairly complete Linux installation for use as a testing tool capable of booting on any x86 computer with a USB port and a bootable floppy drive. RUNT 0.92, the initial version, was released November 27, 2002. Version 4.0 was released November 11, 2004.

Bio::Tools::Run::TribeMCL is a method for clustering proteins into related groups, which are termed protein families.
SYNOPSIS
use Bio::Tools::Run::TribeMCL;
use Bio::SearchIO;
# 3 methods to input the blast results
# straight forward raw blast output (NCBI or WU-BLAST)
my @params = (inputtype=>blastfile);
# OR
# markov program format
# protein_id1 protein_id2 evalue_magnitude evalue_factor
# for example:
# proteins ENSP00000257547 and ENSP00000261659
# with a blast score evalue of 1e-50
# and proteins O42187 and ENSP00000257547
# with a blast score evalue of 1e-119
# entry would be
my @array = [[qw(ENSP00000257547 ENSP00000261659 1 50)],
[qw(O42187 ENSP00000257547 1 119)]];
my @params = (pairs=>@array,I=>2.0);
# OR
# pass in a searchio object
# slowest of the 3 methods as it does more rigourous parsing
# than required for us here
my $sio = Bio::SearchIO->new(-format=>blast,
-file=>blast.out);
my @params=(inputtype=>searchio,I=>2.0);
# you can specify the path to the executable manually in the following way
my @params=(inputtype=>blastfile,I=>2.0,
mcl=>/home/shawn/software/mcl-02-150/src/shmcl/mcl,
matrix=>/home/shawn/software/mcl-02-150/src/contrib/tribe/tribe-matrix);
my $fact = Bio::Tools::Run::TribeMCL->new(@params);
# OR
$fact->matrix_executable(/home/shawn/software/mcl-02-150/src/contrib/tribe/tribe-matrix);
$fact->mcl_executable(/home/shawn/software/mcl-02-150/src/shmcl/mcl);
# to run
my $fact = Bio::Tools::Run::TribeMCL->new(@params);
# Run the program
# returns an array reference to clusters where members are the ids
# for example :2 clusters with 3 members per cluster:
# $fam = [ [mem1 mem2 mem3],[mem1 mem2 mem3]]
# pass in either the blastfile path/searchio obj/the array ref to scores
my $fam = $fact->run($sio);
# print out your clusters
for (my $i = 0; $i
print "Cluster $i t ".scalar(@{$fam->[$i]})." membersn";
foreach my $member (@{$fam->[$i]}){
print "t$membern";
}
}
This clustering is achieved by analysing similarity patterns between proteins in a given dataset, and using these patterns to assign proteins into related groups. In many cases, proteins in the same protein family will have similar functional properties.
Enhancements:
- Perl

fork allows you to run a number of processes in parallel.

fork is a simple Perl script to run a number of processes in parallel. Use it to spread the load of CPU-intensive jobs over multiple processors, or to parallelise jobs that have to wait for the network, such as downloads and backups.

What is it good for?

Two things, really: for speeding up batch processing by using all the CPUs in your system, and for running tasks in parallel that have external dependancies, such as network resources.

In the first case you can speed things up by a factor of the number of CPUs available; in the second case you can reduce the running time of all tasks to that of the slowest task.

Bio::Tools::Run::PiseWorkflow is a class to create a Pise workflow using Pise application objects as methods. A workflow is defined by a set of methods which all instanciate the class PiseApplication.

SYNOPSIS

# First, create a Bio::Tools::Run::AnalysisFactory::Pise object:
my $factory = new Bio::Tools::Run::AnalysisFactory::Pise();
# Then create the application objects (Pise::Run::Tools::PiseApplication):
my $clustalw = $factory->program(clustalw);
$clustalw->infile($my_alignment_file);
my $protpars = $factory->program(protpars);

# You can specify different servers for different applications :
my $protdist = $factory->program(protpars
-remote => http://kun.homelinux.com/cgi-bin/Pise/5.a//protpars.pl,
-email => your_email);

# Create a new workflow object :
my $workflow = Bio::Tools::Run::PiseWorkflow->new();

# Define the workflows methods using the application objects:
# the application method $protpars will receive the output of
# type readseq_ok_alig from the application method $clustalw.
$workflow->addpipe(-method => $clustalw,
-tomethod => $protpars,
-pipetype => readseq_ok_alig);

# The application method $clustalw will be piped to a second
# application method ($protdist) using the output of type readseq_ok_alig.
$workflow->addpipe(-method => $clustalw,
-tomethod => $protdist,
-pipetype => readseq_ok_alig);

# The application method $protpars will be piped to the application
# method $consense using the output of type phylip_tree.
my $consense = $factory->program(consense);
$workflow->addpipe(-method => $protpars,
-tomethod => $consense,
-pipetype => phylip_tree);

# Run the workflow.
$workflow->run();

run in xterm is an servcie menu which adds "run in xterm" & "run in xterm as root" to action menu on binary files, scripts etc.

It has 2 languages: english and polish.

Installation:

copy/save this file in
~/.kde/share/apps/konqueror/servicemenus