Free simplicity patterns software for linux

IPC is a program that calculates the isotopic distribution of a given chemical formula. It gives the rel. intensities and the propability of the masses belonging to a molecule ion, fragment or whatever is represented by the given chemical formula.
Furthernmore it can use GNUPlot to visualize the result. Only masses with a rel. Intensity bigger then 0.009% are shown. Additionaly ipc prints the overall number of peaks and the needed computation time.
The program uses an algorithm which computes the exact isotopic distribution. This leads to a large number of peaks which have very low rel. abundances. Even for a small molecule as Acetylsalicylic acid ( C9H8O4, Mr=180.15) there are 1350 peaks but only nine of them have a rel. abundance higher then 0.01%.
Enhancements:
- A complete list of elements and isotopes is now used.
- The list of elements is taken from the NIST.

Object::PerlDesignPatterns is a Perl architecture for structuring and refactoring large programs.

SYNOPSIS

lynx perldesignpatterns.html
perldoc Object::PerlDesignPatterns

ABSTRACT

Documentation: Ideas for keeping programs fun to hack on even after they grow large. Object, lambda, hybrid structures, Perl specific methods of refactoring, object tricks, anti-patterns, non-structural recurring code patterns.

PerlDesignPatterns is a free book sporting:

Ideas for keeping programs fun to hack on even after they grow large. Object, lambda, hybrid structures, Perl specific methods of refactoring, object tricks, anti-patterns, non-structural recurring code patterns.

Feel free to jump right in and make corrections, suggestions, ask questions, play editor, or just rant. Start in http://www.perldesignpatterns.com/?TinyWiki to learn about the TinyWiki software, make a page for yourself, play with editing that, perhaps make a link from the GuestLog to your page. The markup language is ASCII based - it couldnt be any easier.

This document is a snapshot of the current state of the Wiki, automatically compiled from hundreds of individual sections by a Perl script.

Polyester is a widget style + kwin decoration both aimed to be a good balance between eye candy and simplicity.

Array::PatternMatcher is a pattern matching for arrays.

SYNOPSIS

This section inlines the entire test suite. Please excuse the ok()s.

use Array::PatternMatcher;

Matching logical variables to input stream

# 1 - simple match of logical variable to input
my $pattern = AGE ;
my $input = 969 ;
my $result = pat_match ($pattern, $input, {} ) ;
ok($result->{AGE}, 969) ;

# 2 - if binding exists, it must equal the input
$input = 12;
my $new_result = pat_match ($pattern, $input, $result) ;
ok(!defined($new_result)) ;

# 3 - bind the pattern logical variables to the input list

$pattern = [qw(X Y)] ;
$input = [ 77, 45 ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok($result->{X}, 77) ;
Matching segments (quantifying) portions of the input stream
# 1
{
my $pattern = [a, [qw(X *)], d] ;
my $input = [a, b, c, d] ;

my $result = pat_match ($pattern, $input, {} ) ;
ok ("@{$result->{X}}","b c") ;
}

# 2
{

my $pattern = [a, [qw(X *)], [qw(Y *)], d] ;
my $input = [a, b, c, d] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ("@{$result->{Y}}","b c") ;

}
# 3
{
my $pattern = [a, [qw(X +)], d] ;
my $input = [a, b, c, d] ;
ok ("@{$result->{X}}","b c") ;
}
# 4
{
my $pattern = [ a, [qw(X ?)], c ] ;
my $input = [ a, b, c ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ("$result->{X}","b") ;
}
# 5
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 7) ] ;
my $result = pat_match ($pattern, $input, {} ) ;
ok ($result) ;
}
Single-matching:
Take a single input and a series of patterns and decide which pattern
matches the input:

# 1 - Here all input patterns must match the input

{
my @pattern ;
push @pattern, [ qw(X Y) ] ;
push @pattern, [ qw(22 Z ) ] ;
push @pattern, [ qw(M 33) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ AND?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok ($result->{Z},33) ;
}

# 2 - Here, any one of the patterns must match the input

{
my @pattern ;
push @pattern, [ qw(99 22) ] ;
push @pattern, [ qw(33 22) ] ;
push @pattern, [ qw(44 3) ] ;
push @pattern, [ qw(22 Z) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ OR?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok ($result->{Z},33) ;
}

# 3 - Here, none of the patterns must match the input

{
my @pattern ;
push @pattern, [ qw(99 22) ] ;
push @pattern, [ qw(33 22) ] ;
push @pattern, [ qw(44 3) ] ;
push @pattern, [ qw(22 Z) ] ;

my $input = [ qw(22 33) ] ;

my $meta_pattern = [ NOT?, @pattern ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($meta_pattern, $input, {} ) ;
ok (scalar keys %$result == 0) ;
}

# 4 - here the input must satisfy the predicate
{
sub numberp { $_[0] =~ /d+/ }

my $pattern = [ qw(X age), [qw(IS? N), νmberp] ] ;
my $input = [ qw(Mary age), thirty-four ] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
ok (!defined($result));
}

# 5 - same thing, but this time a failing result ---
# not undef because it is the return val of numberp
{
sub numberp { $_[0] =~ /d+/ }

my $pattern = [ qw(X age), [qw(IS? N), νmberp] ] ;
my $input = [ qw(Mary age), 34 ] ;
my $result = pat_match ($pattern, $input, {} ) ;

ok ($result->{N},34) ;
}
Segment-matching:
Match a chunk of the input stream using *, +, ?

# 1 - * is greedy in this case, but not with 2 consecutve * patterns
{
my $pattern = [a, [qw(X *)], d] ;
my $input = [a, b, c, d] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "X*RETVAL: %s", Data::Dumper::Dumper($result) ;
ok ("@{$result->{X}}","b c") ;
}
# 2 - X* gets nothing, Y* gets all it can:
{

my $pattern = [a, [qw(X *)], [qw(Y *)], d] ;
my $input = [a, b, c, d] ;

# if no bindings, add a binding between pattern and input
my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "X*Y*RETVAL: %s", Data::Dumper::Dumper($result) ;
ok ("@{$result->{Y}}","b c") ;

}
# 3 - samething , but require at least one match for X
{
my $pattern = [a, [qw(X +)], d] ;
my $input = [a, b, c, d] ;

my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "RETVAL: @{$result->{X}}" ;
ok ("@{$result->{X}}","b c") ;
}
# 4 - require 0 or 1 match for X
{
my $pattern = [ a, [qw(X ?)], c ] ;
my $input = [ a, b, c ] ;


my $result = pat_match ($pattern, $input, {} ) ;

ok ("$result->{X}","b") ;
}
# 5 - evaluate a sub on the fly after match
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 7) ] ;

my $result = pat_match ($pattern, $input, {} ) ;

ok ($result) ;
}
# --- 6 same thing, but fail
{
my $pattern = [ qw(X OP Y is Z),
[
sub { "($_->{X} $_->{OP} $_->{Y}) == $_->{Z}" },
IF?
]
] ;
my $input = [qw(3 + 4 is 8) ] ;

my $result = pat_match ($pattern, $input, {} ) ;
warn sprintf "IF_RETVAL2: *%s*", Data::Dumper::Dumper($result);
ok ($result eq ) ;
}

Ghost Diagrams is a project that takes sets of tiles and tries to find patterns into which they may be formed. The patterns it finds when given randomly chosen tiles are often surprising.

It turns out that tiling patterns are a form of computation of equal power to Turing machines, lambda calculus, and cellular automata. For example, here is a tileset implementing "Rule 110", a cellular automaton known to be capable of universal computation.

Considerations similar to the halting problem and Godels theorem apply. There is no upper limit to their capacity to surprise us. Furthermore, tiles have an intuitive quality that other forms of computation lack. You can see how they fit together.

An organism is more than the sum of its organs. When the organs are fitted together, the organism becomes something more. This surprising something more we call "spirit" or "ghost". Ghost Diagrams finds the ghosts implicit in simple sets of tiles.

mtPaint is designed for creating icons and pixel based artwork. mtPaint can edit indexed palette or 24 bit RGB images and offers basic painting and palette manipulation tools.
Its main file format is PNG, although it can also handle JPEG, GIF, TIFF, BMP, XPM and XBM files. Due to its simplicity and lack of dependencies it runs well on GNU/Linux, Windows and older PC hardware.
Main features:
- Edit indexed palette or 24 bit RGB images.
- Load & Save PNG, GIF, JPEG, TIFF, BMP, XPM and XBM files.
- Paint using tools and patterns in one simple main window.
- Protect certain colours on the canvas from being painted over.
- Manipulate digital photos : Crop, scale, rotate, sharpen, soften, emboss, change brightness / contrast / saturation / gamma.
- Up to 100 undo levels.
- Multiple image clipboard.
- View images between 10% and 2000% of their original size.
- English (UK) language by default, Spanish and Czech translations via gettext system (GTK+1: ISO-8859-1 & ISO-8859-2 GTK+2: UTF-8).

Blue Planet is a KDE theme defined by simplicity, usability, dark-blue colors and future look.

Its including background picture that is taken form http://www.guanajuatoenlinea.com .

For those with big resolution:

1600 x 1200 pixels background can be download here:

http://ic3.deviantart.com/images/i/2003/42/2/b/Titan_Blue___221.jpg

Iconset on this screenshots are Futurosoft icons (only changed Go! icon to Fedora default). Download it from here:

http://www.kde-look.org/content/show.php?content=50667

Background color of application is white due to compatibility issues (you can put black but than text isnt readable in some programs).