Free hatch pattern 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.

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

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.

Quantity/Formatter Library provides a Java library made with the quantity/formatter pattern..

Quantity/Formatter Library is a Java library developed in accordance to the quantity/formatter pattern (as demonstrated by the Date/SimpleDateFormat in the standard J2SE library).

The following quantity/formatter pairs are currently available:

Currency/CurrencyFormat,
Density/ DensityFormat,
Dimension/DimensionFormat,
Distance/ DistanceFormat,
ElapsedTime/ElapsedTimeFormat,
Temperature/TemperatureFormat,
Volume/VolumeFormat
Weight/WeightFormat.

KXStitchs aim is to create software to allow the creation and editing of cross stitch patterns. Although software for this type of application has existed on the Windows platform for many years, there has never been an application written specifically for the Linux platform.
KXStitch will be developed for Linux using KDE/QT.
Main features:
- Creation of new patterns
- User defined size
- Selection of material type
- Selection of material colour
- Importing of various picture formats
- Importing images from a scanner
- Importing options will allow
- Limiting colours to a specific palette
- Limiting the number of colours
- Setting of the finished size
- Cropping of the image
- Support for transparancy in images
- Use of an image background for tracing
- Editing of existing patterns
- Editing tools will include
- Open and filled recangles
- Open and filled ellipses
- Filled polylines
- Lines
- Erasing stitches and backstitches
- Colour selection from existing stitch
- Swap colours
- Replace colour
- Cut, copy and paste of rectangular regions
- Stitch type and colour masks can be used to limit the selection
- Undo, Redo
- Mirroring
- Rotation
- Scaling
- Resizing of the canvas
- Extending canvas left, top, right, bottom
- Cropping canvas to the pattern
- Cropping canvas to selection
- Inserting rows and columns
- Centering current pattern on the canvas
- Conversion between floss schemes
- Display scales in Stitches,CM and inches
- Use of various floss palettes, DMC, Anchor, Madeira
- Creation of custom palettes
- Creation of new colours
- Use of standard stitches
- Creation of custom stitches
- Free use of backstitching
- Printing of patterns and floss keys
- (implemented, but needs to be enhanced)
- Mapping of symbols to flosses
- Calibration of floss colours
- Adding notes to patterns
- Full previews with layout tools
- Pattern library
Enhancements:
- Added a new palette manager to replace add floss and remove flosses dialogs
- New palette manager allows allocation of strands for stitches and backstitches
- New palette manager allows allocation of symbols for flosses
- Import / Export of library patterns
- Undo / Redo partially implemented
- Faster rendering speed
- Mouse tracking display in the status bar
- Selection tool and drawing tools scroll the editor screen
- Bug fix for using background images not on the local file system
- Bug fix for filenames used on the command line
- Bug fix page page wrapping

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.

DateTime::Format::Roman is a Perl module with roman day numbering for DateTime objects.

SYNOPSIS

use DateTime::Format::Roman;

my $formatter = DateTime::Format::Roman->new(
pattern => %d %f %b %y );

my $dt = DateTime->new( year => 2003, month => 5, day => 28 );

$formatter->format_datetime($dt);
# 5 Kal Jun 2003

This module formats dates in the Roman style.

The Romans expressed their dates in relation to three fixed dates per month. For example: the Ides of March was the 15th of that month; 14 March was called "2 Ides", 13 March was called "3 Ides", etcetera. The days in the second half of the month were named after the first day of the next month, the "Kalends"; e.g. 16 March was called "17 Kalends of April".

METHODS

new( pattern => $string )

Creates a new formatter object. The optional formatting pattern defines the format of the output of format_datetime(). If no formatting pattern is given, a reasonable default is used.

format_datetime($datetime)

Retruns the formatted string. This method can be called on a formatter object (created by new()), or it can be called as a class method. In the latter case, the default pattern is used.

PATTERN SPECIFIERS

The following specifiers are allowed in the format strings given to the new() method:

%b

The abbreviated month name.

%B

The full month name.

%d

The day of the month as a decimal number (including 1 for the fixed days).

%D

The day of the month, written as a number plus the corresponding fixed day.

%f

The fixed day part of the date.

%m

The month as a decimal number (range 1 to 12).

%y

The year as a decimal number.

If a specifier is preceded by O or o, numbers will be written in uppercase and lowercase Roman numerals, respectively.

The %f specifier accepts an additional argument of 1 digit, specifying the length of the output:

%0f : abbreviated name (e.g. "Kal")
%1f : full name (e.g. "Kalends")
%2f : one-letter abbreviation (e.g. "K")