Free singularity theory software for linux

SINGULAR is a computer algebra system for polynomial computations in commutative algebra, algebraic geometry, and singularity theory.
Its main computational objects are ideals and modules over a large variety of baserings. The baserings are polynomial rings over a field (eg. finite fields, the rationals, floats, algebraic extensions, transcendental extensions), or localizations thereof, or quotient rings with respect to an ideal.
It features fast and general implementations for computing Groebner and standard bases, including Buchbergers algorithm and Moras Tangent Cone algorithm. Its interactive shell and C-like programming language can be extended by libraries written in the SINGULAR programming language.
Main features:
- Main computational objects: ideals/modules over very general polynomial rings over various ground fields.
- Large variety of algorithms implemented in kernel (written in C/C++).
- Many more algorithms implemented as SINGULAR libraries.
- Intuitive, C-like programming language.
- Extensive documentation: Manual (info, ps, and html), Publications.
- Available for most hard- and software platforms: Unix (HP-UX, SunOS, Solaris, Linux, AIX), Windows, Macintosh.
Enhancements:
- This version is mainly a bugfix release, but it also contains some new features.
- Speed was improved for 64-bit architectures.
- The dmod.lib and perron.lib libraries were added.
- center.lib was improved. ncalg.lib was revised.
- New algorithms were added in primdec.lib.
- An improved version of slimgb was incorporated into groebner.
- The module generator (modgen) was improved.
- The build process was improved to build automatically without patches on 64-bit architectures.

Linguistic Tree Constructor is a free program for building linguistic syntax trees from text. Linguistic Tree Constructor lets the user build the tree in a point-and-click fashion.
The program does no analysis on its own -- the user is completely free to draw the tree however he or she wishes. However, the program makes sure that the tree is a tree and not some other kind of graph.
Syntactic theories supported
Three "flavors" of trees are supported:
- "Generic" syntax trees,
- X-Bar syntax trees
- RRG (Role and Reference Grammar) syntax trees (the LSC and the LSNP)
Labeling of nodes
- The program supports adding "labels" to nodes. These labels are userdefinable, and can be used for such things as:
- Rhetorical Structure Theory analyses
- Other discourse-level analyses
- RRG operator-projection analyses
- Subject-Object-Predicate analyses
Main features:
- Draw syntax trees using point-and-click
- Both tree-view and brackets-view are supported
- Supports up to five interlinear lines at word-level
- Interlinear lines can be switched on and off individually
- Change magnification
- Unlimited undo
- Copy (parts of) tree to clipboard as BMP
- Printing + Print Preview
- Uses any font (even Unicode fonts)
- Supports right-to-left languages as well as left-to-right
- Import from straight text (plain text)
- Import from word-per-record SFM interlinear text
- ... and many more...
Enhancements:
- A number of crashes were fixed.
- A bug with magnification on OS X was fixed.
- The speed of interaction with the program was improved.

Lingua::Phonology::Rules is a Perl module for defining and applying phonological rules.

SYNOPSIS

use Lingua::Phonology;
$phono = new Lingua::Phonology;

$rules = $phono->rules;

# Adding and manipulating rules is discussed in the "WRITING RULES"
# section

This module allows for the creation of linguistic rules, and the application of those rules to "words" of Segment objects. You, the user, add rules to a Rules object, defining various parameters and code references that actually perform the action of the rule. Lingua::Phonology::Rules will take care of the guts of applying and creating rules.

The rules you create may have the following parameters. This is just a brief description of the parameters--a more detailed discussion of their effect is in the "WRITING RULES" section.

domain

Defines the domain within which the rule applies. This should be the name of a feature in the featureset of the segments which the rule is applied to.

tier

Defines the tier on which the rule applies. Must be the name of a feature in the feature set for the segments of the word you pass in.

direction

Defines the direction that the rule applies in. Must be either leftward or rightward. If no direction is given, defaults to rightward.

filter

Defines a filter for the segments that the rule applies on. Must a code reference that returns a truth value.

linguistic

Defines a linguistic-style rule to be parsed. When you provide a linguistic-style rule, it is parsed into code references that take the place of the where and do properties listed below. The format of linguistic rules is described in "LINGUISTIC-STYLE RULES" in Lingua::Phonology::FileFormatPOD.

where - defines the condition or conditions where the rule applies. Must be a coderef that returns a truth value. If no value is given, defaults to always true.

do - defines the action to take when the where condition is met. Must be a code reference. If no value is given, does nothing.

result - EXPERIMENTAL. Defines a condition that must be true after the do code has applied. Must be a code reference that returns a truth value. NOTE: This parameter depends on the module Whatif (available from CPAN), and will behave differently if this module is not present. See "Using result".

Lingua::Phonology::Rules is flexible and powerful enough to handle any sequential type of rule system. It cannot handle Optimality Theory-style processes, because those require a fundamentally different kind of algorithm.

Taekwon-Do Theory Assistant tests you on your Taekwon-Do theory in preparation for your gradings.
Taekwon-Do Theory Assistant fires questions at you and you keep going until you get them all right. Taekwon-Do Theory Assistant includes exercises that go up to First Degree Black Belt level.
This program was designed with the GTI (Global Taekwon-Do International) school of Taekwon-Do in mind, which is based on the ITF (International Taekwondo Federation) system, and uses the terminology and refers to the moves and patterns of this system.
Enhancements:
- References to GTI have been removed to give the application more generel appeal.
- The help file URL has also been updated to point to taekwondotheory.co.uk.

LibTomMath is a free open source portable number theoretic multiple-precision integer library written entirely in C. The library is designed to provide a simple to work with API that provides fairly efficient routines that build out of the box without configuration.
The library builds out of the box with GCC 2.95 [and up] as well as Visual C++ v6.00 [with SP5] without configuration. The source code is arranged to make it easy to dive into a particular area very quickly.
The code is also littered with comments [This is one of the on going goals] that help explain the algorithms and their implementations. Ideally the code will serve as an educational tool in the future for CS students studying number theory.
Main features:
Simple Algebraic
- Addition
- Subtraction
- Multiplication
- Squaring
- Division
Digit Manipulation
- Shift left/right whole digits (mult by 2b by moving digits)
- Fast multiplication/division by 2 and 2k for k>1
- Binary AND, OR and XOR gates
Modular Reductions
- Barrett Reduction (fast for any p)
- Montgomery Reduction (faster for any odd p)
- DR Reduction (faster for any restricted p see manual)
- 2k Reduction (fast reduction modulo 2p - k for k < MP_MASK and for k > MP_MASK)
- The exptmod logic can use any of the five reduction algorithms when appropriate with a single function call.
Number Theoretic
- Greatest Common Divisor
- Least Common Multiple
- Jacobi Symbol Computation (falls back to Legendre for prime moduli)
- Multiplicative Inverse
- Extended Euclidean Algorithm
- Modular Exponentiation
- Fermat and Miller-Rabin Primality Tests, utility function such as is_prime and next_prime
Miscellaneous
- Root finding over Z
- Pseudo-random integers
- Signed and Unsigned comparisons
Optimizations
- Fast Comba based Multiplier, Squaring and Montgomery routines.
- Montgomery, Diminished Radix and Barrett based modular exponentiation.
- Karatsuba and Toom-Cook multiplication algorithms.
- Many pointer aliasing optimiztions throughout the entire library.
Enhancements:
- This release fixes one overflow and a minor build issue.
- Otherwise, the code is stable and unchanged.

PDL::LinearAlgebra Perl module contains linear algebra utils for PDL.

SYNOPSIS

use PDL::LinearAlgebra;

$a = random (100,100);
($U, $s, $V) = mdsvd($a);

This module provides a convenient interface to PDL::LinearAlgebra::Real and PDL::LinearAlgebra::Complex.

FUNCTIONS

setlaerror

Set action type when error is encountered, returns previous type. Available values are NO, WARN and BARF (predefined constants). If, for example, in computation of the inverse, singularity is detected, the routine can silently return values from computation (see manuals), warn about singularity or barf. BARF is the default value.

$a = sequence(5,5);
$err = setlaerror(NO);
($inv, $info)= minv($a);
if ($info){
# Change the diagonal (the inverse doesnt exist but its an example)
$a->diagonal(0,1)+=1e-8;
($inv, $info)= minv($a);
}
if ($info){
print "Cant compute the inversen";
}
else{
print "Inverse of $a is $inv";
}
setlaerror($err);

getlaerror

Get error type.

0 => NO,
1 => WARN,
2 => BARF
t
PDL = t(PDL, SCALAR(conj))
conj : Conjugate Transpose = 1 | Transpose = 0, default = 1;

Convenient function for transposing real or complex 2D array(s). For PDL::Complex, if conj is true returns conjugate transpose array(s) and doesnt support dataflow. Supports threading.

issym

PDL = issym(PDL, SCALAR|PDL(tol),SCALAR(hermitian))
tol : tolerance value, default: 1e-8 for double else 1e-5
hermitian : Hermitian = 1 | Symmetric = 0, default = 1;

Check symmetricity/Hermitianicity of matrix. Supports threading.

diag

Return i-th diagonal if matrix in entry or matrix with i-th diagonal with entry. I-th diagonal returned flows data back&forth. Can be used as lvalue subs if your perl supports it. Supports threading.

PDL = diag(PDL, SCALAR(i), SCALAR(vector)))
i : i-th diagonal, default = 0
vector : create diagonal matrices by threading over row vectors, default = 0
my $a = random(5,5);
my $diag = diag($a,2);
# If your perl support lvaluable subroutines.
$a->diag(-2) .= pdl(1,2,3);
# Construct a (5,5,5) PDL (5 matrices) with
# diagonals from row vectors of $a
$a->diag(0,1)

tritosym

Return symmetric or Hermitian matrix from lower or upper triangular matrix. Supports inplace and threading. Uses tricpy or ctricpy from Lapack.

PDL = tritosym(PDL, SCALAR(uplo), SCALAR(conj))
uplo : UPPER = 0 | LOWER = 1, default = 0
conj : Hermitian = 1 | Symmetric = 0, default = 1;
# Assume $a is symmetric triangular
my $a = random(10,10);
my $b = tritosym($a);

positivise

Return entry pdl with changed sign by row so that average of positive sign > 0. In other words thread among dimension 1 and row = -row if Sum(sign(row)) < 0. Works inplace.

my $a = random(10,10);
$a -= 0.5;
$a->xchg(0,1)->inplace->positivise;

mcrossprod

Compute the cross-product of two matrix: A x B. If only one matrix is given, take B to be the same as A. Supports threading. Uses crossprod or ccrossprod.

PDL = mcrossprod(PDL(A), (PDL(B))
my $a = random(10,10);
my $crossproduct = mcrossprod($a);

mrank

Compute the rank of a matrix, using a singular value decomposition. from Lapack.

SCALAR = mrank(PDL, SCALAR(TOL))
TOL: tolerance value, default : mnorm(dims(PDL),inf) * mnorm(PDL) * EPS
my $a = random(10,10);
my $b = mrank($a, 1e-5);

mnorm

Compute norm of real or complex matrix Supports threading.
PDL(norm) = mnorm(PDL, SCALAR(ord));

ord :
0|inf : Infinity norm
1|one : One norm
2|two : norm 2 (default)
3|fro : frobenius norm
my $a = random(10,10);
my $norm = mnrom($a);

mdet

Compute determinant of a general square matrix using LU factorization. Supports threading. Uses getrf or cgetrf from Lapack.

PDL(determinant) = mdet(PDL);
my $a = random(10,10);
my $det = mdet($a);

mposdet

Compute determinant of a symmetric or Hermitian positive definite square matrix using Cholesky factorization. Supports threading. Uses potrf or cpotrf from Lapack.

(PDL, PDL) = mposdet(PDL, SCALAR)
SCALAR : UPPER = 0 | LOWER = 1, default = 0
my $a = random(10,10);
my $det = mposdet($a);

mcond

Compute the condition number (two-norm) of a general matrix.
The condition number (two-norm) is defined:

norm (a) * norm (inv (a)).

Uses a singular value decomposition. Supports threading.

PDL = mcond(PDL)
my $a = random(10,10);
my $cond = mcond($a);

mrcond

Estimate the reciprocal condition number of a general square matrix using LU factorization in either the 1-norm or the infinity-norm.
The reciprocal condition number is defined:

1/(norm (a) * norm (inv (a)))

Supports threading.

PDL = mrcond(PDL, SCALAR(ord))
ord :
0 : Infinity norm (default)
1 : One norm
my $a = random(10,10);
my $rcond = mrcond($a,1);

morth

Return an orthonormal basis of the range space of matrix A.

PDL = morth(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $ortho = morth($a, 1e-8);

mnull

Return an orthonormal basis of the null space of matrix A.

PDL = mnull(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $null = mnull($a, 1e-8);

minv

Compute inverse of a general square matrix using LU factorization. Supports inplace and threading. Uses getrf and getri or cgetrf and cgetri from Lapack and return inverse, info in array context.

PDL(inv) = minv(PDL)
my $a = random(10,10);
my $inv = minv($a);

mtriinv

Compute inverse of a triangular matrix. Supports inplace and threading. Uses trtri or ctrtri from Lapack. Returns inverse, info in array context.

(PDL, PDL(info))) = mtriinv(PDL, SCALAR(uplo), SCALAR|PDL(diag))
uplo : UPPER = 0 | LOWER = 1, default = 0
diag : UNITARY DIAGONAL = 1, default = 0
# Assume $a is upper triangular
my $a = random(10,10);
my $inv = mtriinv($a);

Biomolecule Toolkit project is an Open Source library for the structural modeling of biological macromolecules. The toolkit provides a C++ interface for common tasks in computational structural biology, to facilitate the development of molecular modeling, design, and analysis tools.
Enhancements:
Documentation updates
- Addition of an extensive discussion of the leastsquares_superposition and RMSD-calculation methods, including a description of the mathematical theory behind their operation.
- Fully documented the rotation/translation methods
- Addition of a documented example program ("gyration_radius.cpp")
Bug fixes
- Fixed copy construction bug in PDBAtomDecorator that caused compilation errors in rare situations.
- Fixed a bug in PDBFileParser that caused a compilation error in the PDBSystem copy constructor.
- Fixed a const-conversion bug in GroupedElementIterator which prevented proper interoperation of const and non-const iterator types.
- Fixed a crash-producing bug in stream output for the TypeID class.
- Fixed a math error in RMSD and superposition methods that would corrupt molecule coordinates.
- Fixed a bug that caused all default-constructed PDBAtom objects to be treated as HETATMs.
Feature additions
- Added operator[] to AtomicStructure and PolymerStructure-derived classes.
- Added protected increment() and decrement() operators to TypeID class.
- PDBFileParser can now handle PDB files with ill-formed residue numbering (i.e. Files where residue numbers are repeated in successive chains).

Gambit project is a library of game theory software and tools for the construction and analysis of finite extensive and normal form games.
Gambit is designed to be portable across platforms: it currently is known to run on Linux, FreeBSD, MacOS X, and Windows 98 and later.
Main features:
- A graphical user interface, based upon the wxWidgets (nee wxWindows) library, providing a common look-and-feel across platforms.
- A Python API for scripting applications (under development).
- A library of C++ source code for representing games, suitable for use in other applications.
Enhancements:
- bug fixes