Free construct one software for linux

Construct is a python module for defining arbitrary data structures. Once a data structure (aka, "construct") is defined, it can be used to both parse raw data into an object and build an object into raw data.
Unlike most parsers, it works at the bit-level, so you dont need to worry about parsing individual bits or unaligned fields.
Construct library supports Fields, Unions, Structs and Repeaters; Adapters and Validators; Switches, Pointers and other Meta -constructs.
Main features:
- Symmetrical -- constructs can be used to parse as well as to build
- Bit-level -- can parse and build individual bits, not only bytes
- Ready -- lots of predefined primitives and common protocols definitions, which you can easily use
- Extensible -- you can easily write user-defined constructs by simply by subclassing
- Fast -- benchmarks on my machine show ~160KB/sec can be parsed, fast enough for most situations, and perhaps pysco can improve that
- Declarative -- no procedural code needed for most situations
Enhancements:
- Construct2 is a rewrite of the library, making it faster and much slimmer.
- The library is now byte-oriented instead of bit-oriented, so it uses eight times less memory.
- It can parse files directly from the disk.
- Meta constructs now use lambda instead of eval.
- Textual processing (context free grammar) was added.
- On-demand parsing was added.
- Thorough unit tests were added.
- A full online tutorial is available.

Construo project offers a simple wire frame construction toy.

Construo is a simple 2D construction programm (it is currently not a real game) for objects which consist of rods and springs and let them react on physical forces. You can currently construct buildings and objects like bridges, towers, spaceshuttles, etc. and you let them fall to ground and see seem smash and break.

Sound like fun, doesnt it =;-) The game is similar to Bridge Builder and heavily inspired from the Gamasutra article Collision Response: Bouncy, Trouncy, Fun.

Its covered under the GNU General Public License, thats means source code is availabel and you are allowed to modify it.

The General String library was inspired by the Icon programming language string manipulation features. This library has a GNU license, i.e. it is free. I encourage you to get acquainted with the GNU license and support it if you agree with it.

Icon has two interesting features that are very useful in string manipulation:
Generators: A construct that can generate a sequence of values, and fails when no more values are available.

This is somewhat similar to Javas Iterator. This General String library supports generators through the IGenerator interface.

Backtracking: An operation can consist of two (or more) generators associated together, e.g. through an operator, if the second generator fails, we backtrack to the first generator and retry the operation again.

Think of a database transaction to help you understand backtracking, although they are different. This General String library supports backtracking through the operator classes in the gstring.operators package.

Next is a simple example to show the elegance of these concepts. Suppose that you want to parse a string to find the indexes of vowels:

GString source = new GString("Hello world"); // String to be parsed
SetChar target = new SetChar("aeiou"); // Vowels
IGenerator g = source.doGenerate().find().generator(target); // a find generator
Variant v; // a variant to hold generated positions

// loop until no more generations
do {
v= g.next(); // get next position
if (g.ok()) // if successful generation then print position
System.out.println(v);
} while (g.ok());

The above example will print:
1
4
7

Class::IntrospectionMethods::Catalog can manage catalogs from IntrospectionMethods.

Exported functions

set_method_info( target_class, method_name, info_ref )

Store construction info for method method_name of class target_class.

set_global_catalog (target_class, ...)

Store catalog informations. The first parameter is the class featuring the methods declared in the global catalog.

Following paramaters is a set of named paramaters (e.g. key => value):

name

Mandatory name for the global catalog

list

array ref containing the list of slot and catalog. E.g.:

list => [
[qw/foo bar baz/] => foo_catalog,
[qw/a b z/] => alpha_catalog,
my_object => my_catalog
],
isa

Optional hash ref declaring a containment for catalog. E.g:

list => [ foo => USER ,
admin => ROOT ],
isa => { USER => ROOT }

Then the ROOT catalog will return foo, and the USER catalog will return foo and admin.

help

Optional hash ref (slot_name => help). Store some help information for each slot.

set_global_catalog will construct:

A ClassCatalog object containing the global catalog informations.

A sub_ref containing the ClassCatalog object in a closure.

Returns ( slot_name, sub_ref ). The sub_ref is to be installed in the target class.

When called as a class method, the subref will return the ClassCatalog object. When called as a target class method, the subref will return an ObjectCatalog object associated to the ClassCatalog object stored in the closure.

These 2 object have the same API. ObjectCatalog is used to contain catalog changes that may occur at run-time. ClassCatalog informations will not change.

CoaSim is a tool for simulating the coalescent process with recombination and geneconversion under various demographic models.
CoaSim effectively constructs the ancestral recombination graph for a given number of individuals and uses this to simulate samples of SNP, micro-satellite, and other haplotypes/genotypes.
The generated sample can afterwards be separated in cases and controls, depending on states of selected individual markers. The tool can accordingly also be used to construct cases and control data sets for association studies.
CoaSim is developed in collaboration between Bioinformatics ApS and Bioinformatics Research Center (BiRC).
CoaSim is written in C++ and Guile Scheme and is available as source code (under the GNU General Public License, GPL) and as binary versions as Linux RPM files. The source code has been successfully compiled on various Linux and UNIX systems, under OS X and under Windows with Cygwin.
As I have only limited access to architectures other than Linux, it is not possible for me to make binary distributions for other platforms, but if anyone is willing to build the distributions I will be more than happy to put them on this site.
Enhancements:
- Callbacks for population structure events (bottlenecks, migration, etc.) have been added.
- A major bug that caused the starting and ending times of epochs to be wrong in some cases (starting too late or never terminating) has been fixed.

Math::String::Charset::Nested is a charset for Math::String objects.

SYNOPSIS

use Math::String::Charset;

# construct a charset from bigram table, and an initial set (containing
# valid start-characters)
# Note: After an a, either an b, c or a can follow, in this order
# After an d only an a can follow
$bi = new Math::String::Charset ( {
start => a..d,
bi => {
a => [ b, c, a ],
b => [ c, b ],
c => [ a, c ],
d => [ a, ],
q => [ ], # q will be automatically in end
}
end => [ a, b, ],
} );
print $bi->length(); # a,b => 2 (cross of end and start)
print scalar $bi->class(2); # count of combinations with 2 letters
# will be 3+2+2+1 => 8

GNU Robots project is a robot construction game.
GNU Robots is a game/diversion where you construct a program for a little robot, then watch him explore a world.
The world is filled with baddies that can hurt you, objects that you can bump into, and food that you can eat.
The goal of the game is to collect as many prizes as possible before you are killed by a baddie or you run out of energy.
GNU Robots is a game/diversion where you construct a program for a little robot, then watch him explore a world. The world is filled with baddies that can hurt you, objects that you can bump into, and food that you can eat. The goal of the game is to collect as many prizes as possible before are killed by a baddie or you run out of energy. GNU Robots (including source) will be released under the GNU General Public License.
The GNU Robots playing field is filled with food (increases energy), prizes (to increase your score), walls (which you can bump into), and baddies (which can inflict damage.)
To make the program easier to design and implement, I have decided to let the robot program be written in a text file, so that advanced programmers dont have to limit themselves to a visual programming interface. The language will be Scheme, which provides for flexibility in writing your programs. For non-programmers, there will also be a visual programming interface, which will generate Scheme code.
GNU Robots uses GNU Guile as the language back-end (Scheme). This will make the GNU Robots game engine more consistent with other GNU projects, as it will use the same extension language.
Enhancements:
- Added some extra documentation (but not much) and the early beginning of code clean-up.

TuxMathScrabble is a math-version of the popular board game for children aged 4-10. The game features drag-and-drop tiles for the user, while Tux moves his own.

The game challenges young people to construct compound equations and consider multiple abstract possibilities.

Dancing penguins come out of the tiles when your move is correct (like a cuckoo-clock). Tux is animated as well.