ltl2ba implements an algorithm of P. Gastin and D. Oddoux to generate
Buechi automata from linear temporal logic (LTL) formulae. This
algorithm generates a very weak alternating automaton and then
transforms it into a Buechi automaton, using a generalized Buechi
automaton as an intermediate step. Each automaton is simplified
on-the-fly in order to save memory and time. As usual the LTL formula
is simplified before any treatment. ltl2ba is more efficient than
Spin 3.4.1, with regard to the size of the resulting automaton,
the time of the computation, and the memory used.
The Matrix Template Library (MTL) is a high-performance generic component
library that provides comprehensive linear algebra functionality for a wide
variety of matrix formats.
As with the Standard Template Library (STL), MTL uses a five-fold approach,
consisting of generic functions, containers, iterators, adaptors, and function
objects, all developed specifically for high performance numerical linear
algebra. Within this framework, MTL provides generic algorithms corresponding
to the mathematical operations that define linear algebra. Similarly, the
containers, adaptors, and iterators are used to represent and to manipulate
concrete linear algebra objects such as matrices and vectors.
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.
This is generate_html.
This package provides functions for generating HTML pages that contain
the help texts for a set of functions. The package is designed to be as
general as possible, but also contains convenience functions for
generating a set of pages for entire packages.
OGDF (Open Graph Drawing Framework) is a self-contained C++ class library for
the automatic layout of diagrams. OGDF offers sophisticated algorithms and data
structures to use within your own applications or scientific projects.
The library provides:
* A wide range of graph drawing algorithms that allow to reuse and replace
particular algorithm phases by using a dedicated module mechanism.
* Sophisticated data structures that are commonly used in graph drawing,
equipped with rich public interfaces.
* Self-contained code that does not require any additional libraries
(except for some optional branch-and-cut algorithms).
Math::GMPq is a bigrational module utilising the GNU MP (GMP) library. Basically
this module simply wraps all of the mpq rational functions provided by that
library. See the Math::GMPq test suite for some examples of usage.
IMPORTANT:
If your perl was built with '-Duse64bitint' you need to assign all integers
larger than 52-bit in a 'use integer;' block. Failure to do so can result in the
creation of the variable as an NV (rather than an IV) - with a resultant loss of
precision.
This package supplies a set of functions that find the roots of
polynomials. Polynomials up to the quartic may be solved directly by
numerical formulae. Polynomials of fifth and higher powers will be
solved by an iterative method, as there are no general solutions for
fifth and higher powers.
The linear, quadratic, cubic, and quartic *_roots() functions all
expect to have a non-zero value for the $a term.
If the constant term is zero then the first value returned in the list
of answers will always be zero, for all functions.
This module is an extension to the Math::Symbolic module. A basic
familiarity with that module is required.
The Math::Symbolic::Custom::Pattern module implements pattern matching
routines on Math::Symbolic trees. The patterns itself are constructed from
Math::Symbolic trees with just a few variables which have a special
meaning.
The module provides two interfaces. You can use the new() and match()
methods this class provides, or you can use the to_pattern() and
is_of_form() methods on any Math::Symbolic tree. (Exported by the
Math::Symbolic::Custom::Pattern::Export module. Refer to that module for
details on is_of_form().)
The cdecimal is a fast drop-in replacement for the decimal module in Python's
standard library. Both modules provide complete implementations of the General
Decimal Arithmetic Specification.
Typical performance gains are between 30x for I/O heavy benchmarks and 80x for
numerical programs. In a database benchmark, cdecimal exhibits a speedup of
12x over decimal.py.
decimal cdecimal speedup
pi 42.75s 0.58s 74x
telco 172.19s 5.68s 30x
psycopg 3.57s 0.29s 12x
All Python versions from 2.5 up to 3.2 are supported. For the few remaining
differences, read the cdecimal documentation. cdecimal has been included in
Python-3.3.
colormath is a simple Python module that spares the user from directly dealing
with color math.
Some features include:
* Support for a wide range of color spaces. A good chunk of the CIE spaces,
RGB, HSL/HSV, CMY/CMYK, and many more.
* Conversions between the various color spaces. For example, XYZ to sRGB,
Spectral to XYZ, CIE Lab to Adobe RGB.
* Calculation of color difference. All CIE Delta E functions, plus CMC.
* Chromatic adaptations (changing illuminants).
* RGB to hex and vice-versa.
* 16-bit RGB support.
TetGen is a program for generating tetrahedral meshes for arbitrary 3D
domains. The main purpose of TetGen is to create high-quality tetrahedral
meshes for solving partial differential equations using finite element
and finite volume methods. This program, based on Delaunay methods,
currently generates meshes including exact constrained Delaunay
tetrahedralizations and quality (conforming Delaunay) meshes. For a 3D
point set, it generates its exact Delaunay tetrahedralization and convex
hull as well. The program is written in ANSI C++. It is highly portable,
it should be very easy to compile and run on all major computer systems.
It can be also used as a library embedded into other applications.