Free dimensioned software for linux

iPuissance 4D is probably one of the best Connect-Four style game. Its played with red and yellow counters on a vertical grid of 6x7, closed at the bottom. In turns each player drops a counter of his colour in the column of his choice, until one of them makes a line of 4 counters of his colour, like in Morpion. Easy you think? But its not and if you dont like it, just change the rules.

Come and play against other players on the net. The games grid is rendered in three dimensions, displays players score, time left... To easily find players on Internet you can connect to our Beroux.com server for free and play with all the players connected on the server and gain points, or chat with them. Players are ranked. You can train by playing against the computer. You think youll be in the hightscore?

PDL::Primitive Perl module contains primitive operations for pdl.

This module provides some primitive and useful functions defined using PDL::PP and able to use the new indexing tricks.

See PDL::Indexing for how to use indices creatively. For explanation of the signature format, see PDL::PP.

Inner product over one dimension

c = sum_i a_i * b_i
, BadDoc => If a() * b() contains only bad data, c() is set bad. Otherwise c() will have its bad flag cleared, as it will not contain any bad values., ); # pp_def( inner )

pp_def( outer, HandleBad => 1, Pars => a(n); b(m); [o]c(n,m);, Code => loop(n,m) %{ $c() = $a() * $b(); %}, BadCode => loop(n,m) %{ if ( $ISBAD(a()) || $ISBAD(b()) ) { $SETBAD(c()); } else { $c() = $a() * $b(); } %}, Doc => =for ref

outer product over one dimension

Naturally, it is possible to achieve the effects of outer product simply by threading over the "*" operator but this function is provided for convenience.
); # pp_def( outer )

pp_addpm( $c = pdl([[3],[4]]); # A column vector
perldl> $c = pdl(3,4)->(*1); # A column vector, using NiceSlice
perldl> $m = pdl([[1,2],[3,4]]); # A 2x2 matrix
Now that we have a few objects prepared, here is how to matrix-multiply them:
perldl> print $r x $m # row x matrix = row
[
[ 7 10]
]

perldl> print $m x $r # matrix x row = ERROR
PDL: Dim mismatch in matmult of [2x2] x [2x1]: 2 != 1

perldl> print $m x $c # matrix x column = column
[
[ 5]
[11]
]

perldl> print $m x 2 # Trivial case: scalar mult.
[
[2 4]
[6 8]
]

perldl> print $r x $c # row x column = scalar
[
[11]
]

perldl> print $c x $r # column x row = matrix
[
[3 6]
[4 8]
]

webImageTool is a service menu that extracts height and width from an image and builds the html tag from it.

This is usefull for webdesigners.

Example:

Copy Image dimension => height="768" width="1024"
Copy HTML-TAG => img src="PATH TO FILENAME/FILENAME" border="0" alt="FILENAME">

NetCDF is a format developed at Unidata that was inspired by the CDF format from NASA.
NetCDF stands for "Network Common Data Form" and is a self-describing data format, commonly used in scientific and engineering applications.
Main features:
- All features of netCDF 3.6
- Large file support (> 2 GB data files)
- Use of HDF5 for storage
- Backward file-format compatibility
- Backward API compatibility
- Parallel I/O
- Multiple unlimited dimensions
- Additional Data Types
- Hierarchical Grouping of Data
- Bit packing
- Compression and other filters
- Revised documentation
- Examples
- Distribution with both netCDF and HDF5 packages
- (Unicode/ASCII) String data type
- Anonymous dimensions
- Support for compound data types, including nested compound types
- User-defined data type
- Upgrades to ncgen/ncdump/CDL to reflect new features
- NcML support for ncgen/ncdump
- F90 interface
- C++ interface
- Demonstrable performance gains in modeling contexts on advanced architectures
- HDF5 file driver support
Whats New in 4.0 Alpha 11 Development Release:
- Enum type added.
- NetCDF-4 verified support of common data model.
- ncdump support new features and NcML.
- No netCDF-4 artifacts in file.
- Uses HDF5 creation order information.
- NetCDF-4 documentation complete.
Whats New in 3.6.2 Stable Release:
- Support for shared libraries was added.
- Major documentation additions were done.
- Speedups were made on little-endian machines.
- Minor bugs were fixed.

PDL::NiceSlice Perl module contains a nicer slicing syntax for PDL.

SYNOPSYS

use PDL::NiceSlice;

$a(1:4) .= 2; # concise syntax for ranges
print $b((0),1:$end); # use variables in the slice expression
$a->xchg(0,1)->(($pos-1)) .= 0; # default method syntax

$idx = long 1, 7, 3, 0; # a piddle of indices
$a(-3:2:2,$idx) += 3; # mix explicit indexing and ranges
$a->clump(1,2)->(0:30); # default method syntax
$a(myfunc(0,$var),1:4)++; # when using functions in slice expressions
# use parentheses around args!

$b = $a(*3); # Add dummy dimension of order 3

# modifiers are specified in a ;-separated trailing block
$a($a!=3;?)++; # short for $a->where($a!=3)++
$a(0:1114;_) .= 0; # short for $a->flat->(0:1114)
$b = $a(0:-1:3;|); # short for $a(0:-1:3)->sever
$n = sequence 3,1,4,1;
$b = $n(;-); # drop all dimensions of size 1 (AKA squeeze)
$b = $n(0,0;-|); # squeeze *and* sever
$c = $a(0,3,0;-); # more compact way of saying $a((0),(3),(0))

# Use with perldl versions < v1.31 (or include these lines in .perldlrc)
perldl> use PDL::NiceSlice;
# next one is required, see below
perldl> $PERLDL::PREPROCESS = &PDL::NiceSlice::perldlpp;
perldl> $a(4:5) .= xvals(2);

Slicing is a basic, extremely common operation, and PDLs slice method would be cumbersome to use in many cases. PDL::NiceSlice rectifies that by incorporating new slicing syntax directly into the language via a perl source filter (see the perlfilter man page). NiceSlice adds no new functionality, only convenient syntax.

NiceSlice is loaded automatically in the perldl shell, but (to avoid conflicts with other modules) must be loaded automatically in standalone perl/PDL scripts (see below). If you prefer not to use a prefilter on your standalone scripts, you can use the slice method in those scripts, rather than the more compact NiceSlice constructs.

PDL::Transform is a Perl module that coordinate transforms, image warping, and N-D functions.

SYNOPSIS

use PDL::Transform;
my $t = new PDL::Transform:: ( )

$out = $t->apply($in) # Apply transform to some N-vectors (Transform method)
$out = $in->apply($t) # Apply transform to some N-vectors (PDL method)

$im1 = $t->map($im); # Transform image coordinates (Transform method)
$im1 = $im->map($t); # Transform image coordinates (PDL method)

$t2 = $t->compose($t1); # compose two transforms
$t2 = $t x $t1; # compose two transforms (by analogy to matrix mult.)

$t3 = $t2->inverse(); # invert a transform
$t3 = !$t2; # invert a transform (by analogy to logical "not")

PDL::Transform is a convenient way to represent coordinate transformations and resample images. It embodies functions mapping R^N -> R^M, both with and without inverses. Provision exists for parametrizing functions, and for composing them. You can use this part of the Transform object to keep track of arbitrary functions mapping R^N -> R^M with or without inverses.

The simplest way to use a Transform object is to transform vector data between coordinate systems. The apply method accepts a PDL whose 0th dimension is coordinate index (all other dimensions are threaded over) and transforms the vectors into the new coordinate system.

Transform also includes image resampling, via the map method. You define a coordinate transform using a Transform object, then use it to remap an image PDL. The output is a remapped, resampled image.

You can define and compose several transformations, then apply them all at once to an image. The image is interpolated only once, when all the composed transformations are applied.

In keeping with standard practice, but somewhat counterintuitively, the map engine uses the inverse transform to map coordinates FROM the destination dataspace (or image plane) TO the source dataspace; hence PDL::Transform keeps track of both the forward and inverse transform.

For terseness and convenience, most of the constructors are exported into the current package with the name t_ , so the following (for example) are synonyms:

$t = new PDL::Transform::Radial(); # Long way

$t = t_radial(); # Short way

Several math operators are overloaded, so that you can compose and invert functions with expression syntax instead of method syntax (see below).