Free pattern software for linux

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.

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

Pattern Classification Program is an open-source machine learning program for supervised and unsupervised classification of patterns (vectors of measurements). Pattern Classification Program implements the following algorithms and methods:
- k-means clustering
- Fishers linear discriminant
- dimension reduction using Singular Value Decomposition
- Principal Component Analysis
- feature subset selection
- Bayes error estimation
- parametric classifiers (linear and quadratic)
- least-squares (pseudo-inverse) linear discriminant
- k-Nearest Neighbor
- neural networks (Multi-Layer Perceptron)
- Support Vector Machine algorithm
- cross-validation
- bagging (committee) classification
The program supports interactive and batch processing. Commands are issued through a keyboard-driven menu system in the interactive mode, or in a batch file in the batch mode. It is a binary executable and does not need any special run-time environment. PCP uses tab-delimited text files for input data. The results are displayed on the screen and saved in text files.
PCP runs under Linux and Windows operating systems (under Cygwin environment), on i386 architecture CPUs such as Intel Pentium or AMD Athlon. PCP has been developed and tested on RedHat Linux 9.0 distribution. It has also been tested on SUSE Linux 9.1 and Fedora Core 2 and verified to run on Knoppix 3.7 and Windows XP.
Enhancements:
- This release supports model selection for the linear SVM kernel and an option to build SVD transforms using training and test datasets (as opposed to just training data).
- P-errors are now reported in SVM model selection.
- The build process was simplified.

pyTrommler is a cross platform drum machine that is loosely based on the now defunct Trommler project. pyTrommler supports WAV files as samples and features real-time audio playback.
Main features:
- Distributed under the GPL.
- Works under Linux, BSD, Windows.
- Graphical user interface based on GTK.
- Supporty complex rhythms (variable number of beats per pattern)
- Virtual drum "@ACCENT" to emphasize certain beats.
- 16 bit 44100kHz mono or stereo drum samples (individual stereo panning and volume adjustment)
- Realtime (stereo) audio output using SDL library.
- Alternatively, audio output to a wav file.
Enhancements:
- This release cleans up a lot of minor bugs and adds real time pattern/beat tracking.

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

libwrapiter is a library that provides wrappers for C++ STL style iterators.
It makes it easy to define generic iterator wrappers, which remove the need to expose underlying data structures when working with classes using STL containers.
Purpose:
Consider the following massively oversimplified example. Were using the private implementation pattern or pimpl to avoid sticking too much in the header files.
myproject/myclass.hh without libwrapiter
#include < list >
namespace myproject
{
class MyClass
{
private:
///name implementation data, using the private implementation pattern
///{
struct Implementation;
Implementation * _imp;
///}
///name disallow copying and assignment
///{
MyClass(const MyClass &);
const MyClass & operator= (const MyClass &);
///}
public:
MyClass();
~MyClass();
///name iterate over our items
///{
typedef std::list ::const_iterator Iterator;
Iterator begin() const;
Iterator end() const;
///}
};
}
Enhancements:
- Headers are now split into -fwd, -decl, and -impl, allowing finer grained control to give faster compile times.
- The old, undecorated header paths are still fine if you dont need this kind of control.
- libwrapiter has a new homepage.

SPServer project is a server framework library written on C++ that implements the Half-Sync/Half-Async pattern.

SPServer is a server framework library written on C++ that implements the Half-Sync/Half-Async pattern ( http://www.cs.wustl.edu/~schmidt/PDF/HS-HA.pdf ). Its based on libevent in order to utilize the best I/O loop on any platform.

SPServer can simplify TCP server construction. It is a hybrid system between threaded and event-driven, and exploits the advantages of both programming models. It exposes a threaded programming style to programmers, while simultaneously using event-driven style to process network connection.

XML::PatAct::ToObjects is an action module for creating Perl objects.

SYNOPSIS

use XML::PatAct::ToObjects;

my $patterns = [ PATTERN => [ OPTIONS ],
PATTERN => "PERL-CODE",
... ];

my $matcher = XML::PatAct::ToObjects->new( Patterns => $patterns,
Matcher => $matcher,
CopyId => 1,
CopyAttributes => 1 );

XML::PatAct::ToObjects is a PerlSAX handler for applying pattern-action lists to XML parses or trees. XML::PatAct::ToObjects creates Perl objects of the types and contents of the action items you define.

New XML::PatAct::ToObject instances are creating by calling `new(). Parameters can be passed as a list of key, value pairs or a hash. `new() requires the Patterns and Matcher parameters, the rest are optional:

Patterns
The pattern-action list to apply.

Matcher
An instance of the pattern or query matching module.

CopyId
Causes the `ID attribute, if any, in a source XML element to be copied to an `ID attribute in newly created objects. Note that IDs may be lost of no pattern matches that element or an object is not created (-make) for that element.

CopyAttributes
Causes all attributes of the element to be copied to the newly created objects.

Each action can either be a list of options defined below or a string containing a fragment of Perl code. If the action is a string of Perl code then simple then some simple substitutions are made as described further below.