Debian Science Mathematics-dev packages

DOLFIN is the Python and C++ interface of the FEniCS project for the automated solution of differential equations, providing a consistent PSE (Problem Solving Environment) for solving ordinary and partial differential equations. Key features include a simple, consistent and intuitive object-oriented API; automatic and efficient evaluation of variational forms; automatic and efficient assembly of linear systems; and support for general families of finite elements.

This package will always depend on the most recent version of libdolfinX-dev (X=version), so if you install it then you will get upgrades automatically.

FFLAS-FFPACK consists in the creation of a set of routines, giving the same tools as a set of classical Basic Linear Algebra Subroutines, but working over finite fields. In the same way, some other routines of higher level (such as the one in LAPACK) are also produced.

Armadillo is a streamlined C++ linear algebra library (matrix maths) aiming towards a good balance between speed and ease of use. Integer, floating point and complex numbers are supported, as well as a subset of trigonometric and statistics functions. Optional integration with LAPACK and ATLAS libraries is also provided.

This package has the development libraries and headers for Armadillo.

ARPACK software is capable of solving large scale symmetric, nonsymmetric, and generalized eigenproblems from significant application areas. The software is designed to compute a few (k) eigenvalues with user specified features such as those of largest real part or largest magnitude. Storage requirements are on the order of n*k locations. No auxiliary storage is required. A set of Schur basis vectors for the desired k-dimensional eigen-space is computed which is numerically orthogonal to working precision. Numerically accurate eigenvectors are available on request.

This package contains the static libraries and the documentation for development with libarpack (including examples).

ATLAS is an approach for the automatic generation and optimization of numerical software. Currently ATLAS supplies optimized versions for the complete set of linear algebra kernels known as the Basic Linear Algebra Subroutines (BLAS), and a subset of the linear algebra routines in the LAPACK library.

This package includes the static libraries and symbolic links needed for program development.

This package is a binary incompatible upgrade to the blas-dev package. Several minor changes to the C interface have been incorporated.

BLAS (Basic Linear Algebra Subroutines) is a set of efficient routines for most of the basic vector and matrix operations. They are widely used as the basis for other high quality linear algebra software, for example lapack and linpack. This implementation is the Fortran 77 reference implementation found at netlib.

This package contains a static version of the library.

Blitz++ offers a high level of abstraction, but performance which rivals Fortran. The current version supports arrays and vectors.

This package contains the static library and header files for compiling programs with blitz++.

CGAL (Computational Geometry Algorithms Library) makes the most important of the solutions and methods developed in computational geometry available to users in industry and academia in a C++ library. The goal is to provide easy access to useful, reliable geometric algorithms.

This package contains the header files and static libraries for libCGAL.so, libCGAL_Core.so, and libCGAL_ImageIO.so. The header files and static libraries for libCGAL_Qt4.so can be found in the package libcgal-qt4-dev.

Neartree is an API and a library for finding nearest neighbors among points in spaces of arbitrary dimensions. This package provides a C++ template, TNear.h, and C library and header files for compiling programs using Neartree.

Quaternions are four-dimensional numbers which form an associative normed division algebra over the real numbers. Unit quaternions are a convenient and efficient way to represent orientations and rotations in three dimensions.

CQRlib is an ANSI C implementation of a utility library for quaternion arithmetic and quaternion rotation math.

This package contains files needed for compiling programs using CQRlib.

CVector is an ANSI C library which implements dynamic arrays approximating the functionality of the C++ vector class. It provides functions to create and manipulate an abstract vector container. Vector elements can be of any datatype.

This package contains files needed for compiling programs using CVector.

FreeFem++ is an implementation of a language dedicated to the finite element method. It enables you to solve Partial Differential Equations (PDE) easily.

Problems involving PDE from several branches of physics such as fluid-structure interactions require interpolations of data on several meshes and their manipulation within one program. FreeFem++ includes a fast quadtree-based interpolation algorithm and a language for the manipulation of these data on multiple meshes. It contains also a powerful mesh generation and adaption tool integrated seamlessly in FreeFem++ called bamg.

FreeFem++ is written in C++ and the FreeFem++ language is a C++ idiom allowing for a smooth learning curve.

This package contains the development files of FreeFem++.

FreeFEM is a language adapted to Partial Differential equation. The underlying method used is the Finite Element Method. This tool has been successfully used as a teaching tool and even as a research tool.

Givaro is a C++ library for arithmetic and algebraic computations. Its main features are implementations of the basic arithmetic of many mathematical entities: Primes fields, Extensions Fields, Finite Fields, Finite Rings, Polynomials, Algebraic numbers, and Arbitrary precision integers and rationals (C++ wrappers over gmp).

Givaro also provides data-structures and templated classes for the manipulation of basic algebraic objects, such as vectors, matrices (dense, sparse, structured), univariate polynomials (and therefore recursive multivariate).

It contains different program modules and is fully compatible with the LinBox linear algebra library and the Athapascan environment, which permits parallel programming.

This package contains development files for Givaro.

GLPK (GNU Linear Programming Kit) is intended for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It is a set of routines written in ANSI C and organized in the form of a callable library.

This package contains static library, headers, and the development manpage for libvc.

The GNU Scientific Library (GSL) is a collection of routines for numerical analysis. The routines are written from scratch by the GSL team in C, and present a modern API for C programmers, while allowing wrappers to be written for very high level languages.

This package contains the header files, static libraries and symbolic links that developers using GNU GSL will need.

Hypre is a set of matrix preconditioning libraries to aid in the solution of large systems of linear equations.

This package contains the headers and symlinks necessary to develop programs which use hypre.

ITSOL is a library of iterative solvers for general sparse linear systems of equations. ITSOL can be viewed as an extension of the itsol module in SPARSKIT. It is written in C and offers a selection of recently developed preconditioners. The preconditioner suite includes:

• ILUK (ILU preconditioner with level of fill)
• ILUT (ILU preconditioner with threshold)
• ILUC (Crout version of ILUT)
• VBILUK (variable block preconditioner with level of fill - with automatic block detection)
• VBILUT (variable block preconditioner with threshold - with automatic block detection)
• ARMS (Algebraic Recursive Multilevel Solvers -- includes actually several methods - In particular the standard ARMS and the ddPQ version which uses nonsymmetric permutations)

Note that ITSOL is a scalar package. You may find parallel implentations of some of the preconditioners listed above in pARMS.

This package provides the itsol header files required to compile C/C++ programs that use ITSOL.

JAMA/C++ was adapted for The Template Numerical Toolkit (TNT) from JAMA, a Java Matrix Library, developed jointly by the Mathworks and NIST. See http://math.nist.gov/javanumerics/jama for more information.

TNT is a collection of interfaces and reference implementations of numerical objects useful for scientific computing in C++. The toolkit defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. The goal of this package is to provide reusable software components that address many of the portability and maintenance problems with C++ codes.

TNT provides a distinction between interfaces and implementations of TNT components. For example, there is a TNT interface for two-dimensional arrays which describes how individual elements are accessed and how certain information, such as the array dimensions, can be used in algorithms; however, there can be several implementations of such an interface: one that uses expression templates, or one that uses BLAS kernels, or another that is instrumented to provide debugging information. By specifying only the interface, applications codes may utilize such algorithms, while giving library developers the greatest flexibility in employing optimization or portability strategies.

 Homepage: [http://math.nist.gov/tnt/](http://math.nist.gov/tnt/)

LAPACK version 3.X is a comprehensive FORTRAN library that does linear algebra operations including matrix inversions, least squared solutions to linear sets of equations, eigenvector analysis, singular value decomposition, etc. It is a very comprehensive and reputable package that has found extensive use in the scientific community.

This package provides the header files and static libraries.

Life is a versatile finite element library to solve partial differential equations.

Support 1D, 2D, 3D

Support the following basic entities: simplices (segment, triangle, tetrahedron) and product of simplices (quadrangle, hexahedron)

Support various point sets on these basic entities: equispaced points, quadrature points, interpolation points (Gauss-Lobatto, Fekete, WarpBlend?)

Support continuous and discontinuous Galerkin methods

Support various polynomial sets:

• Lagrange(continuous,discontinuous,all dimensions,all interpolation point sets)

• Dubiner(discontinuous), boundary adapted(continuous)

• Legendre(discontinuous), boundary adapted(continuous)

Provide mathematical concept for higher order abstraction (Function spaces and associated elements, forms and operators)

Provide a language embedded in C++ for variational formulations, projection and numerical integration

Lip interpolates scattered multivariate data with a Lipschitz function.

Methods of interpolation of multivariate scattered data are scarce. The programming library Lip implements a new method by G. Beliakov, which relies on building reliable lower and upper approximations of Lipschitz functions. If we assume that the function that we want to interpolate is Lipschitz-continuous, we can provide tight bounds on its values at any point, in the worse case scenario. Thus we obtain the interpolant, which approximates the unknown Lipschitz function f best in the worst case scenario. This translates into reliable learning of f, something that other methods cannot do (the error of approximation of most other methods can be infinitely large, depending on what f generated the data).

Lipschitz condition implies that the rate of change of the function is bounded:

|f(x)-f(y)|<M||x-y||.

It is easily interpreted as the largest slope of the function f. f needs not be differentiable.

The interpolant based on the Lipschitz properties of the function is piecewise linear, it possesses many useful properties, and it is shown that it is the best possible approximation to f in the worst case scenario. The value of the interpolant depends on the data points in the immediate neigbourhood of the point in question, and in this sense, the method is similar to the natural neighbour interpolation.

There are two methods of construction and evaluation of the interpolant. The explicit method processes all data points to find the neighbours of the point in question. It does not require any preprocessing, but the evaluation of the interpolant has linear complexity O(K) in terms of the number of data.

"Fast" method requires substantial preprocessing in the case of more than 3-4 variables, but then it provides O(log K) evaluation time, and thus is suitable for very large data sets (K of order of 500000) and modest dimension (n=1-4). For larger dimension, explicit method becomes practically more efficient. The class library Lip implements both fast and explicit methods.

This package contains the development files (headers, so and static libraries) for MAdLib.

MAdLib is a library that performs global node repositioning and mesh adaptation by local mesh modifications on tetrahedral or triangular meshes. It is designed to frequently adapt the mesh in transient computations. MAdLib is written in C++.

The adaptation procedure is driven by two objectives:

• make the edge lengths as close as possible to a (non-homogenous)

  prescribed length,

• maintain a satisfying element quality everywhere.

MAdLib can be used in transient computations in order to maintain a satisfying element quality (moving boundaries, multiphase flows with interface tracking, ...) or/and to apply selective refinements and coarsenings (error estimators based, interface capturing: shocks, free surfaces, ...).

GNU libmatheval is a library comprising of several procedures that make it possible to create an in-memory tree representation of mathematical functions over single or multiple variables and later use this representation to evaluate functions for specified variable values, to create corresponding trees for function derivatives over specified variables or to print textual representations of in-memory trees to a specified string. The library supports arbitrary variable names in expressions, decimal constants, basic unary and binary operators and elementary mathematical functions.

This package contains the header files and static library.

matio is an ISO C library (with a limited Fortran 90 interface) for reading and writing Matlab MAT files.

This package contains the development files needed to compile software to use the libmatio API.

MEI stands for Mathematical Expression Interpreter. It is intended to provide interpretation of mathematical formula in a string. It is destined to be used by scientific codes (Computational Fluid Dynamics).

This package contains the development files needed to compile software to use the libmei API.

The libMesh library is a C++ framework for the numerical simulation of partial differential equations on serial and parallel platforms. Development began in March 2002 with the intent of providing a friendly interface to a number of high-quality software packages that are publicly available. Currently the library supports 1D, 2D, and 3D steady and transient finite element and finite volume simulations. PETSc is currently used for the solution of linear systems on both serial and parallel platforms.

This package contains the C++ header files and shared library links (only needed for developing programs with libmesh).

muParser is a high performance mathematical parser library, written in pure C++. It is based on transforming an expression into a bytecode and precalculating constant parts of it.

This package contains the development files.

Newmat library is intended for scientists and engineers who need to manipulate a variety of types of matrices using standard matrix operations. Emphasis is on the kind of operations needed in statistical calculations such as least squares, linear equation solve and eigenvalues.

Newmat supports matrix types: Matrix (rectangular matrix); UpperTriangularMatrix; LowerTriangularMatrix; DiagonalMatrix; SymmetricMatrix; BandMatrix; UpperBandMatrix; LowerBandMatrix; SymmetricBandMatrix; IdentityMatrix; RowVector; ColumnVector.

Only one element type (float or double) is supported (default is double).

The library includes the operations , +, -, =, +=, -=, Kronecker product, Schur product, concatenation, inverse, transpose, conversion between types, submatrix, determinant, Cholesky decomposition, QR triangularisation, singular value decomposition, eigenvalues of a symmetric matrix, sorting, fast Fourier and trig. transforms and printing.

libnewmat-dev contains static libraries, headers, and some documentation.

NETGEN is an automatic 3d tetrahedral mesh generator. It accepts input from constructive solid geometry (CSG) or boundary representation (BRep) from STL file format. The connection to a geometry kernel allows the handling of IGES and STEP files. NETGEN contains modules for mesh optimization and hierarchical mesh refinement.

This package contains the static libraries and header files.

The core of PolyBoRi is a C++ library, which provides high-level data types for Boolean polynomials and monomials, exponent vectors, as well as for the underlying polynomial rings and subsets of the powerset of the Boolean variables. As a unique approach, binary decision diagrams are used as internal storage type for polynomial structures. On top of this C++-library, PolyBoRi provides a Python interface. This allows parsing of complex polynomial systems, as well as sophisticated and extendable strategies for Groebner base computation. PolyBoRi features a powerful reference implementation for Groebner basis computation.

This package contains the PolyBoRi development files.

This package supports both a double-double datatype (approx. 32 decimal digits) and a quad-double datatype (approx. 64 decimal digits). The computational library is written in C++. Both C++ and Fortran-90 high-level language interfaces are provided to permit one to convert an existing C++ or Fortran-90 program to use the library with only minor changes to the source code.

RanLip generates random variates with an arbitrary multivariate Lipschitz density.

While generation of random numbers from a variety of distributions is implemented in many packages (like GSL library http://www.gnu.org/software/gsl/ and UNURAN library http://statistik.wu-wien.ac.at/unuran/), generation of random variate with an arbitrary distribution, especially in the multivariate case, is a very challenging task. RanLip is a method of generation of random variates with arbitrary Lipschitz-continuous densities, which works in the univariate and multivariate cases, if the dimension is not very large (say 3-10 variables).

Lipschitz condition implies that the rate of change of the function (in this case, probability density p(x)) is bounded:

|p(x)-p(y)|<M||x-y||.

From this condition, we can build an overestimate of the density, so called hat function h(x)>=p(x), using a number of values of p(x) at some points. The more values we use, the better is the hat function. The method of acceptance/rejection then works as follows: generatea random variate X with density h(x); generate an independent uniform on (0,1) random number Z; if p(X)<=Z h(X), then return X, otherwise repeat all the above steps.

RanLip constructs a piecewise constant hat function of the required density p(x) by subdividing the domain of p (an n-dimensional rectangle) into many smaller rectangles, and computes the upper bound on p(x) within each of these rectangles, and uses this upper bound as the value of the hat function.

Files provided by this package are required to develop new programs with the Scythe library. There is no binary library associated with these headers, i.e. all template code is contained within and no further dependencies are required at runtime

The Scythe Statistical Library is an open source C++ library for statistical computation. It includes a suite of matrix manipulation functions, a suite of pseudo-random number generators, and a suite of numerical optimizers. Programs written using Scythe are generally much faster than those written in commonly used interpreted languages, such as R, Matlab, and GAUSS; and can be compiled on any system with the GNU GCC compiler (and perhaps with other C++ compilers). One of the primary design goals of the Scythe developers has been ease of use for non-expert C++ programmers. Ease of use is provided through three primary mechanisms: (1) operator and function over-loading, (2) numerous pre-fabricated utility functions, and (3) clear documentation and example programs. Additionally, Scythe is quite flexible and entirely extensible because the source code is available to all users.

SLEPc is a software library for the solution of large scale sparse eigenvalue problems on parallel computers. It is an extension of PETSc and can be used for either standard or generalized eigenproblems, with real or complex arithmetic. It can also be used for computing a partial SVD of a large, sparse, rectangular matrix.

This package contains the static libraries, shared links, and header files for SLEPC.

SPARSKIT a basic tool-kit for sparse matrix computations. Sparskit is a general purpose FORTRAN-77 library for sparse matrix computations. It has been gathered over several years and includes some of the most useful tools for developing and implementing sparse matrix techniques, particularly for iterative solvers. If you need a simple routine for doing a sparse matrix operation (e.g., adding two sparse matrices, or reordering a sparse matrix) it is likely to be available in SPARSKIT. SPARSKIT also contains most of the iterative accelarators and a number of efficient preconditioners.

SPOOLES is a library for solving sparse real and complex linear systems of equations, written in the C language using object oriented design.

This package contains the SPOOLES development files.

STXXL provides an STL replacement using an abstraction layer to storage devices to allow for the optimal layout of data structures. This allows for multi-terabyte datasets to be held and manipulated in standard C++ data structures, whilst abstracting the complexity of managing this behaviour efficiently. STXXL utilises multi-disk I/O to speed up I/O bound calculations. STXXL has been developed at the University of Karlsruhe.

Development libraries for STXXL, required for building programs that utilise the STXXL library

Suitesparse is a collection of libraries for computations involving sparse matrices. This package includes the following libraries:

AMD approximate minimum degree ordering

CAMD symmetric approximate minimum degree

BTF permutation to block triangular form (beta)

COLAMD column approximate minimum degree ordering

CCOLAMD constrained column approximate minimum degree ordering

CHOLMOD sparse Cholesky factorization

CSparse a concise sparse matrix package

CXSparse CSparse extended: complex matrix, int and long int support

KLU sparse LU factorization, primarily for circuit simulation

LDL a simple LDL' factorization

UMFPACK sparse LU factorization

This package contains the static libraries and header files.

SuperLU is a general purpose library for the direct solution of large, sparse, nonsymmetric systems of linear equations on high performance machines. The library is written in C and is callable from either C or Fortran. The library routines will perform an LU decomposition with partial pivoting and triangular system solves through forward and back substitution. The LU factorization routines can handle non-square matrices but the triangular solves are performed only for square matrices. The matrix columns may be preordered (before factorization) either through library or user supplied routines. This preordering for sparsity is completely separate from the factorization. Working precision iterative refinement subroutines are provided for improved backward stability. Routines are also provided to equilibrate the system, estimate the condition number, calculate the relative backward error, and estimate error bounds for the refined solutions.

The Template Numerical Toolkit (TNT) is a collection of interfaces and reference implementations of numerical objects useful for scientific computing in C++. The toolkit defines interfaces for basic data structures, such as multidimensional arrays and sparse matrices, commonly used in numerical applications. The goal of this package is to provide reusable software components that address many of the portability and maintenance problems with C++ codes.

TNT provides a distinction between interfaces and implementations of TNT components. For example, there is a TNT interface for two-dimensional arrays which describes how individual elements are accessed and how certain information, such as the array dimensions, can be used in algorithms; however, there can be several implementations of such an interface: one that uses expression templates, or one that uses BLAS kernels, or another that is instrumented to provide debugging information. By specifying only the interface, applications codes may utilize such algorithms, while giving library developers the greatest flexibility in employing optimization or portability strategies.

 Homepage: [http://math.nist.gov/tnt/](http://math.nist.gov/tnt/)

The Trilinos Project is an effort to develop and implement robust parallel algorithms using modern object-oriented software design, while still leveraging the value of established numerical libraries such as PETSc, Aztec, the BLAS and LAPACK. It emphasizes abstract interfaces for maximum flexibility of component interchanging, and provides a full-featured set of concrete classes that implement all abstract interfaces.

This package contains the headers and static libraries.

This metapackage will always depend on the most recent version of petscX-dev (X=version), so if you install it then you will get upgrades automatically.

The FEniCS Form Compiler FFC provides state-of-the-art automatic and efficient evaluation of general multilinear forms (variational formulations) for FEniCS. FFC functions as the form evaluation system for DOLFIN but can also be used to compile forms for other systems.

FFC works as a compiler for multilinear forms by generating code (C or C++) for the evaluation of a multilinear form given in mathematical notation. This new approach to form evaluation makes it possible to combine generality with efficiency; the form can be given in mathematical notation and the generated code is as efficient as hand-optimized code.

Numpy contains a powerful N-dimensional array object, sophisticated (broadcasting) functions, tools for integrating C/C++ and Fortran code, and useful linear algebra, Fourier transform, and random number capabilities.

Numpy replaces the python-numeric and python-numarray modules which are now deprecated and shouldn't be used except to support older software.

Numerical optimization framework developed in Python which provides connections to lots of solvers with easy and unified OpenOpt syntax. Problems which can be tackled with OpenOpt

• Linear Problem (LP)
• Mixed-Integer Linear Problem (MILP)
• Quadratic Problem (QP)
• Non-Linear Problem (NLP)
• Non-Smooth Problem (NSP)
• Non-Linear Solve Problem (NLSP)
• Least Squares Problem (LSP)
• Linear Least Squares Problem (LLSP)
• Mini-Max Problem (MMP)
• Global Problem (GLP)

A variety of solvers is available (e.g. IPOPT, ALGENCAN).

The core of PolyBoRi is a C++ library, which provides high-level data types for Boolean polynomials and monomials, exponent vectors, as well as for the underlying polynomial rings and subsets of the powerset of the Boolean variables. As a unique approach, binary decision diagrams are used as internal storage type for polynomial structures. On top of this C++-library we provide a Python interface. This allows parsing of complex polynomial systems, as well as sophisticated and extendable strategies for Groebner base computation. PolyBoRi features a powerful reference implementation for Groebner basis computation.

This package contains the PolyBoRi Python module and ipbori program.

UFC (Unified Form-assembly Code) is a unified framework for finite element assembly. More precisely, it defines a fixed interface for communicating low level routines (functions) for evaluating and assembling finite element variational forms. The UFC interface consists of a single header file ufc.h that specifies a C++ interface that must be implemented by code that complies with the UFC specification. Examples of form compilers that support the UFC interface are FFC and SyFi.

This package contains Python utilities for generating UFC code.

UFL (Unified Form Language) is a unified language for definition of variational forms intended for finite element discretization. More precisely, it defines a fixed interface for choosing finite element spaces and defining expressions for weak forms in a notation close to mathematical notation. The form compilers FFC and SyFi use UFL as their end-user interface, producing UFC implementations as their output.

UFC (Unified Form-assembly Code) is a unified framework for finite element assembly. More precisely, it defines a fixed interface for communicating low level routines (functions) for evaluating and assembling finite element variational forms. The UFC interface consists of a single header file ufc.h that specifies a C++ interface that must be implemented by code that complies with the UFC specification. Examples of form compilers that support the UFC interface are FFC and SyFi.

cfortran.h is an easy-to-use powerful bridge between C and FORTRAN. It provides a completely transparent, machine independent interface between C and FORTRAN routines (= subroutines and/or functions) and global data, i.e. structures and COMMON blocks.

FFLAS-FFPACK consists in the creation of a set of routines, giving the same tools as a set of classical Basic Linear Algebra Subroutines, but working over finite fields. In the same way, some other routines of higher level (such as the one in LAPACK) are also produced.

This package provies developer's documentation of FFLAS-FFPACK.

FFLAS-FFPACK consists in the creation of a set of routines, giving the same tools as a set of classical Basic Linear Algebra Subroutines, but working over finite fields. In the same way, some other routines of higher level (such as the one in LAPACK) are also produced.

This package provies user's documentation of FFLAS-FFPACK.

Givaro is a C++ library for arithmetic and algebraic computations. Its main features are implementations of the basic arithmetic of many mathematical entities: Primes fields, Extensions Fields, Finite Fields, Finite Rings, Polynomials, Algebraic numbers, and Arbitrary precision integers and rationals (C++ wrappers over gmp).

Givaro also provides data-structures and templated classes for the manipulation of basic algebraic objects, such as vectors, matrices (dense, sparse, structured), univariate polynomials (and therefore recursive multivariate).

It contains different program modules and is fully compatible with the LinBox linear algebra library and the Athapascan environment, which permits parallel programming.

This is a transitional dummy package, Debian no longer ships Developer Documentation for Givaro. This 'givaro-dev-doc' package can be safely removed from the system if no other package depends on it.

IT++ is a C++ library of mathematical, signal processing and communication classes and functions. Its main use is in simulation of communication systems and for performing research in the area of communications. The kernel of the library consists of generic vector and matrix classes, and a set of accompanying routines. Such a kernel makes IT++ similar to MATLAB or GNU Octave .

This package has the development libraries and headers for IT++.

A convex polyhedron is the set of points satisfying a finite family of linear inequalities. The study of the vertices and extreme rays of such systems is important and useful in e.g. mathematics and optimization. In a dual interpretation, finding the vertices of a (bounded) polyhedron is equivalent to finding the convex hull (bounding inequalities) of an (arbitrary dimensional) set of points. Lrs (lexicographic reverse search) has two important features that can be very important for certain applications: it works in exact arithmetic, and it consumes memory proportional to the input, no matter how large the output is.

This package contains the optional static libraries and headers, useful for developers.

OpenTURNS is a powerful and generic tool to treat and quantify uncertainties in numerical simulations in design, optimization and control. It allows both sensitivity and reliability analysis studies:

• defining the outputs of interest and decision criterion;
• quantify and model the source of uncertainties;
• propagate uncertainties and/or analyse sensitivity and
• rank the sources of uncertainty

OpenTURNS is a large project with more than 300 C++ classes which uses well known and supported software such as R for the statistical methods and BLAS/LAPACK for the linear algebra.

This package provides the OpenTURNS headers should be used if one wants to link its application against the library.

qrupdate is a Fortran library for QR and Cholesky decompositions. It is most notably used by Octave.

This package contains the static library.

OpenTURNS is a powerful and generic tool to treat and quantify uncertainties in numerical simulations in design, optimization and control. It allows both sensitivity and reliability analysis studies: defining the outputs of interest and decision criterion; quantify and model the source of uncertainties; propagate uncertainties and/or analyse sensitivity and rank the sources of uncertainty

OpenTURNS is a large project with more than 300 C++ classes which uses well known and supported software such as R for the statistical methods and BLAS/LAPACK for the linear algebra.

This package provides a wrapper that allows any external code to be linked against the OpenTURNS library and to be used through the library functionalities.

Any code can be used provided that it can be seen as a numerical function that reads N doubles and returns P doubles. Notice that the wrapper of this package only shows how to link against the OpenTURNS library. It does not show how to parse or write the arguments of the function so they can be sent to or retrieved from the code.

OpenTURNS is a powerful and generic tool to treat and quantify uncertainties in numerical simulations in design, optimization and control. It allows both sensitivity and reliability analysis studies:

• defining the outputs of interest and decision criterion;
• quantify and model the source of uncertainties;
• propagate uncertainties and/or analyse sensitivity and
• rank the sources of uncertainty

OpenTURNS is a large project with more than 300 C++ classes which uses well known and supported software such as R for the statistical methods and BLAS/LAPACK for the linear algebra.

This package provides a textual user interface that gives access to all the functionalities provided by the OpenTURNS library.

nauty (no automorphisms, yes?) is a set of procedures for determining the automorphism group of a vertex-coloured graph. It provides this information in the form of a set of generators, the size of the group, and the orbits of the group. It is also able to produce a canonically-labelled isomorph of the graph, to assist in isomorphism testing. This package provides a C API.

TetGen generates the Delaunay tetrahedralization, Voronoi diagram, and convex hull for three-dimensional point sets, generates the constrained Delaunay tetrahedralizations and quality tetrahedral meshes for three-dimensional domains with piecewise linear boundary.

This package provides header file and static library.

The core of PolyBoRi is a C++ library, which provides high-level data types for Boolean polynomials and monomials, exponent vectors, as well as for the underlying polynomial rings and subsets of the powerset of the Boolean variables. As a unique approach, binary decision diagrams are used as internal storage type for polynomial structures. On top of this C++-library we provide a Python interface. This allows parsing of complex polynomial systems, as well as sophisticated and extendable strategies for Groebner base computation. PolyBoRi features a powerful reference implementation for Groebner basis computation.

This package contains the PolyBoRi computationsl algebra development files.

levmar is a native ANSI C implementation of the Levenberg-Marquardt optimization algorithm. Both unconstrained and constrained (under linear equations, inequality and box constraints) Levenberg-Marquardt variants are included. The LM algorithm is an iterative technique that finds a local minimum of a function that is expressed as the sum of squares of nonlinear functions. It has become a standard technique for nonlinear least-squares problems and can be thought of as a combination of steepest descent and the Gauss-Newton method. When the current solution is far from the correct on, the algorithm behaves like a steepest descent method: slow, but guaranteed to converge. When the current solution is close to the correct solution, it becomes a Gauss-Newton method.

This package contains the header file and the demo program.