Free reliably repeatable pattern software for linux

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 ) ;
}

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.

Pattern-lab is a pattern recognition program. Pattern-lab project is optimized for OCR, but not constrained to it. The method used is mainly pattern matching. Separation of merged patterns is one of the main goals. It is currently under development.
Enhancements:
- This release adds the Standardizing Transformation (ST) embedding IMage Euclidean Distance (IMED) in the preprocessing phase.
- Positive and negative effects of the new feature are explained in the manual.

Bulli Epu is an interactive program for generating parquet deformations (tilings with progressive changes across the pattern).

There is both a free version and, for a small donation, one with a few extra features. Both are written in Java and run via Java Web-Start.

Inline::Java::PerlInterpreter is a Perl module used to call Perl directly from Java using Inline::Java.

SYNOPSIS

import org.perl.inline.java.* ;

class HelpMePerl {
static private InlineJavaPerlInterpreter pi = null ;

public HelpMePerl() throws InlineJavaException {
}

static private boolean matches(String target, String pattern)
throws InlineJavaPerlException, InlineJavaException {
Boolean b = (Boolean)pi.eval("" + target + " =~ /" + pattern + "/", Boolean.class) ;
return b.booleanValue() ;
}

public static void main(String args[])
throws InlineJavaPerlException, InlineJavaException {
pi = InlineJavaPerlInterpreter.create() ;

String target = "aaabbbccc" ;
String pattern = "ab+" ;
boolean ret = matches(target, pattern) ;

System.out.println(
target + (ret ? " matches " : " doesnt match ") + pattern) ;

pi.destroy() ;
}
}

WARNING: Inline::Java::PerlInterpreter is still experimental.
The org.perl.inline.java.InlineJavaPerlInterpreter Java class allows you to load a Perl interpreter directly from Java. You can then perform regular callbacks to call into Perl.

JuggleMaster project is a juggling siteswap animator.
JuggleMaster is a cross-platform juggling animator [understanding siteswap].
Anyone who doesnt know what siteswap is can still download it and look at the patterns that come with it, and examine the cool stuff they could do if they did understand it.
Enhancements:
- all: Makefile voodoo
- jmqt: initial add
- jmlib: Added patterns.h and patterns.cpp, which parse pattern files
- data: Added some style data for completeness
- jmdlx: Added printing mpegs. Thanks to luap for the color stuff.
- jmdlx: Added printing images
- jmdlx: HUGE list of fixes and changes from arkanes in #wxwidgets
- jmdlx: Added Visual Studio build stuff, also arkanes
- jmpocket: initial add
- jmlib: minor jmpocket compatability fixes

NarkozaTEAM provides a simple project management system using the Model-View-Controller design pattern.

NarkozaTeam is a package of classes that implements a simple project management system using the Model-View-Controller design pattern.

The package uses the WACT framework, but expands it with user authentication modification.

Debyer project takes as an input a file with atom positions and can output x-ray and neutron diffraction pattern, total scattering structure function, pair distribution function (PDF) and related functions (RDF, reduced PDF).

It can be run on any modern platform, from typical Linux or MS Windows workstation to large computer clusters. The parallel version uses MPI library.

Debyer is distributed under the terms of GNU General Public License.