Debian Math Mathematics-dev packages

Die grundlegenden Funktionen von Code_Saturne ermöglichen die Bearbeitung von entweder inkompressiblen oder expandierbaren Strömungen mit oder ohne Wärmetransport und Turbulenz. Spezielle Module sind verfügbar für spezielle physikalische Probleme wie Wärmeübertragung durch Strahlung, Verbrennung (Gas, Kohle, Schweröl, ...), Magnetohydrodynamik, kompressible Strömungen, Zweiphasenströmungen (Euler-Lagrange-Ansatz mit Zweiwege-Kopplung), Erweiterungen für spezielle Anwendungen (z.B. das Mercure_Saturne-Modell für atmosphärische Berechnungen).

Mittels MPI arbeitet die Software auf Maschinen mit verteiltem Speicher parallel. Sie wird seit 1997 bei EDF R&D entwickelt. Sie beruht auf einem Ansatz benachbarter finiter Volumen, der Netze mit allen Arten von Zellen (tetraedisch, hexaedisch, prismatisch, pyramidenförmig, polyedrisch, …) und jede Art der Gitterstruktur (unstrukturiert, blockstrukturiert, hybrid, übereinstimmend oder mit hängenden Knoten, …) akzeptiert.

Dieses Paket enthält die Programmdateien.

Die grundlegenden Funktionen von Code_Saturne ermöglichen die Bearbeitung von entweder inkompressiblen oder expandierbaren Strömungen mit oder ohne Wärmetransport und Turbulenz. Spezielle Module sind verfügbar für spezielle physikalische Probleme wie Wärmeübertragung durch Strahlung, Verbrennung (Gas, Kohle, Schweröl, ...), Magnetohydrodynamik, kompressible Strömungen, Zweiphasenströmungen (Euler-Lagrange-Ansatz mit Zweiwege-Kopplung), Erweiterungen für spezielle Anwendungen (z.B. das Mercure_Saturne-Modell für atmosphärische Berechnungen).

Mittels MPI arbeitet die Software auf Maschinen mit verteiltem Speicher parallel. Sie wird seit 1997 bei EDF R&D entwickelt. Sie beruht auf einem Ansatz benachbarter finiter Volumen, der Netze mit allen Arten von Zellen (tetraedisch, hexaedisch, prismatisch, pyramidenförmig, polyedrisch, …) und jede Art der Gitterstruktur (unstrukturiert, blockstrukturiert, hybrid, übereinstimmend oder mit hängenden Knoten, …) akzeptiert.

Dieses Paket enthält die Include-Dateien.

The Coin-MP optimizer is an open source solver, it is part of the COIN-OR project which is an initiative to spur the development of open-source software for the operations research community.

CoinMP is a C-API library that supports most of the functionality of CLP (Coin LP), CBC (Coin Branch-and-Cut), and CGL (Cut Generation Library) projects.

This package contains the files needed to build applications using libCoinMP.

CppAD is a package for automatic differentiation (AD) of algorithms written in C++. Given appropriately written C++ code that computes a function, CppAD augments it to also compute derivative values. The system uses templates, supports forward and reverse accumulation modes, and allows nested derivatives.

This transition package helps with the move to libcppad-dev.

FEniCS ist eine Sammlung von freier Software für automatisches und effizientes Lösen von Differentialgleichungen.

FEniCS besitzt umfangreiche Fähigkeiten, wie z. B. automatisches Lösen von Variationsproblemen, automatisierte Fehlerkontrolle und Anpassungsmöglichkeiten, eine umfassende Bibliothek finiter Elemente, leistungsfähige lineare Algebra und vieles mehr.

FEniCS ist als eine Sammlung interoperabler Komponenten organisiert, es beinhaltet u. a. den Lösungsfinder DOLFIN (für Modelle basierend auf partiellen Differentialgleichungen), den Compiler FFC (für finite Elemente unterschiedlicher Form), den Finite-Elemente-Tabulator FIAT, den »just-in-time«-Compiler Instant, die Code-Generierungs-Schnittstelle UFC, die Formensprache UFL und eine Reihe zusätzlicher Komponenten.

Dies ist ein Metapaket, das von allen FEniCS-Komponenten abhängt.

Dies ist die Vorgängerversion FEniCS. Es sollte die Installation der nächsten Generation von FEniCS (FEniCS-X im Paket fenicx) in Betracht gezogen werden.

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.

Diese Bibliothek berechnet FFTs in einer oder mehreren Dimensionen. Sie ist extrem schnell. Dieses Paket enthält die statisch gelinkte Bibliothek und die Header-Dateien.

GAP ist ein System für diskrete Computeralgebra, mit besonderem Schwerpunkt auf rechnergestützter Gruppentheorie. GAP bietet eine Programmiersprache, eine in der GAP-Sprache geschriebene Bibliothek mit tausenden von Funktionen, die algebraische Algorithmen umsetzen sowie große Datenbibliotheken von algebraischen Objekten. GAP wird in Forschung und Lehre für die Untersuchung von Gruppen und ihren Darstellungen, Ringen, Vektorräumen, Algebren, kombinatorischen Strukturen und vielem mehr verwendet.

Dieses Paket enthält den GAP-Compiler sowie die notwendigen Header- und Objekt-Dateien für den Bau von GAP-Paketen.

Der GAP-Compiler (GAC) erstellt aus GAP-Code C-Code und ruft anschließend den C-Compiler der Systems auf, um daraus Maschinencode zu erzeugen. Dies kann den Prozess beschleunigen.

The JEL library enables users to enter algebraic expressions into their program. Since JEL converts expressions directly into Java bytecode, it significantly speeds up their evaluation time. If the user's Java virtual machine has a JIT compiler, expressions are transparently compiled into native machine code.

JEL may be a very useful tool for a variety of applications in science involving user-defined functions, e.g. to create plots, to apply fits to a data set and to solve integrals or differential equations. Another relevant use case for JEL is given by algebraic operations between two or more columns of a database table.

ALGLIB is a cross-platform numerical analysis and data processing library. This package support C++. ALGLIB features include:

• Linear algebra (direct algorithms, EVD/SVD)
• Solvers (linear and nonlinear)
• Interpolation
• Optimization
• Fast Fourier transforms
• Numerical integration
• Linear and nonlinear least-squares fitting
• Ordinary differential equations
• Special functions
• Statistics (descriptive statistics, hypothesis testing)
• Data analysis (classification/regression, including neural networks)

This package contains the development files (headers and documentation) for ALGLIB.

Approximate Nearest Neighbor (ANN) ist eine C++-Bibliothek, die Datenstrukturen und -algorithmen für Exact- und Approximate-Nearest-Neighbor-Suchen in beliebig hohen Dimensionen unterstützt. ANN nimmt an, dass die Messung aller Abstände mit Distanzfunktionen erfolgt, die zu den Minkowski-Metriken gehören. Das schließt den bekannten euklidischen Abstand, die Manhattan- sowie die Maximum-Distanz ein. ANN arbeitet mit Datensätzen in der Größenordnung von tausenden bis hunderttausenden Punkten und bis zu 20 Dimensionen.

Dieses Paket enthält die Header-Dateien für die Entwicklung von Anwendungen mit der ANN-Bibliothek.

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++ is an object-oriented version of the ARPACK package. It consists a collection of classes that offers c++ programmers an interface to ARPACK. It preserves the full capability, performance, accuracy and low memory requirements of the FORTRAN package, but takes advantage of the c++ object-oriented programming environment.

ARPACK stands for ARnoldi PACKage and provides standard and generalized eigenvalue solvers for sparse matrices that arises typically from finite element codes. See the corresponding Debian package.

Die ARPACK-Software kann umfangreiche symmetrische, unsymmetrische und generalisierte Eigenwertprobleme aus wichtigen Anwendungsbereichen lösen. Sie wurde entwickelt, um ein paar (k) Eigenwerte mit vom Benutzer vorgegebenen Merkmalen wie dem größten Realteil oder dem größten Betrag zu berechnen. Die Speicheranforderungen sind in der Größenordnung von n*k Speicherzellen. Es ist kein Hilfsspeicher erforderlich. Es wird ein Satz von Schur-Basisvektoren für den gewünschten k-dimensionalen Eigenraum berechnet, der im Rahmen der Rechengenauigkeit numerisch orthogonal ist. Auch numerisch genaue Eigenvektoren können abgefragt werden.

Dieses Paket enthält die statischen Bibliotheken und die Dokumentation für die Entwicklung mit libarpack (einschließlich Beispielen).

Dieses Paket ist ein binär nicht kompatibles Upgrade des Pakets blas-dev. Mehrere geringfügige Änderungen an der C-Schnittstelle wurden berücksichtigt.

BLAS (Basic Linear Algebra Subroutines) ist eine Sammlung von effizienten Routinen für die Mehrzahl der grundlegenden Vektor- und Matrizenoperationen. Sie werden häufig als Basis für andere qualitativ hochwertige Software für Lineare Algebra, z.B. lapack und linpack, verwendet. Diese Implementierung ist die bei netlib erhältliche Fortran-77-Referenzimplementierung.

Dieses Paket enthält eine statische Version der Bibliothek.

BLIS is a portable software framework for instantiating high-performance BLAS-like dense linear algebra libraries. The framework was designed to isolate essential kernels of computation that, when optimized, immediately enable optimized implementations of most of its commonly used and computationally intensive operations. BLIS is written in ISO C99 and available under a new/modified/3-clause BSD license. While BLIS exports a new BLAS-like API, it also includes a BLAS compatibility layer which gives application developers access to BLIS implementations via traditional BLAS routine calls. An object-based API is also available for more experienced users.

The package pulls development files for one of the 32-bit BlasInt variants.

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++.

libbraiding is a library to compute several properties of braids, including centralizer and conjugacy check.

It is based on CBraid by Jae Choon Cha and Braiding by Juan Gonzalez-Meneses.

This package contains the development files for the library.

The core of BRiAl 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 a Python interface is provided. This allows parsing of complex polynomial systems, as well as sophisticated and extendable strategies for Groebner base computation. BRiAl features a powerful reference implementation for Groebner basis computation.

This package contains the BRiAl core development files.

The cddlib library is a C library for manipulating general convex polyhedra. It supports converting between the system of linear inequalities representation and a vertices and extreme rays representation of a polyhedron, and also supports solving linear programming problems.

This package contains the cddlib development files.

Minpack includes software for solving nonlinear equations and nonlinear least squares problems. Five algorithmic paths each include a core subroutine and an easy-to-use driver. The algorithms proceed either from an analytic specification of the Jacobian matrix or directly from the problem functions. The paths include facilities for systems of equations with a banded Jacobian matrix, for least squares problems with a large amount of data, and for checking the consistency of the Jacobian matrix with the functions.

This is the C re-write of the original fortran minpack implementation.

This package contains development files needed to build cminpack applications.

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.

The library uses the Nearest Neighbor algorithm after Kalantari and McDonald, (IEEE Transactions on Software Engineering, v. SE-9, pp. 631-634,1983) modified to use recursion instead of a double-linked tree and simplified so that it does less checking for things like is the distance to the right less than the distance to the left; it was found that these checks make little to no difference.

The Combinatorial BLAS (CombBLAS) is an extensible distributed-memory parallel graph library offering a small but powerful set of linear algebra primitives specifically targeting graph analytics.

• The Combinatorial BLAS development influences the Graph BLAS standardization process.
• It achieves scalability via its two dimensional distribution and coarse-grained parallelism.
• CombBLAS powers HipMCL, a highly-scalable parallel implementation of the Markov Cluster Algorithm (MCL).
• Operations among sparse matrices and vectors use arbitrary user defined semirings.

This package provides development files for building client applications against combblas.

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 ist eine ANSI-C-Bibliothek, die dynamische Arrays implementiert, welche annähernd der Funktionalität der C++-Klasse vector entsprechen. Sie stellt Funktionen zur Erzeugung und Manipulation eines abstrakten Vektor-Containers bereit. Die Elemente des Vektors können einen beliebigen Datentyp haben.

Dieses Paket enthält die erforderlichen Dateien für das Kompilieren von Programmen, die CVector nutzen.

deal.II is a C++ program library targeted at the computational solution of partial differential equations using adaptive finite elements. It uses state-of-the-art programming techniques to offer you a modern interface to the complex data structures and algorithms required.

This package contains the development files.

Solves unconstrained nonlinear least squares problems using Powell's dog-leg method. The user specifies a callback C function that returns the value and gradients of the model function at a particular operating point. This library takes a series of dog-leg steps to find a local minimum of the residual surface.

This library works with sparse matrices, which makes it suitable for efficiently solving very large problems.

Development files

Diese Bibliothek stellt Routinen zur Umwandlung von IEEE-Fließkommazahlen einfacher (float) und doppelter (double) Genauigkeit zu und von Zeichenketten bereit. Die Bibliothek bietet viel Flexibilität im Hinblick auf das Konvertierungsformat: kürzeste, feste, präzise oder exponentielle Darstellung; dezimale, hexadezimale oder oktale Basis; Kontrolle über die Anzahl der Stellen, vorangestellte/abschließende Nullen und Leerzeichen.

Die Bibliothek besteht aus effizienten Konvertierungsroutinen, die aus der JavaScript-Engine V8 entnommen wurden. Der Code wurde strukturell überarbeitet (refactoring) und verbessert, so dass er leichter in anderen Projekten verwendet werden kann.

Dieses Paket enthält eine statische Version der Bibliothek und Entwicklungs-Header.

DUNE, the Distributed and Unified Numerics Environment is a modular toolbox for solving partial differential equations (PDEs) with grid-based methods. It supports the easy implementation of methods like Finite Elements (FE), Finite Volumes (FV), and also Finite Differences (FD).

This package contains the development files for the grid interface.

This library implements 2-descent on elliptic curves over Q and computations with modular symbols.

This package contains the development files for the library.

This is a dummy package.

Eigen 3 ist eine leichtgewichtige C++-Vorlagenbibliothek für Vektor- und Matrixmathematik, auch bekannt als Lineare Algebra.

Im Gegensatz zu den meisten anderen Bibliotheken für Lineare Algebra konzentriert sich Eigen 3 auf die einfachen mathematischen Bedürfnisse von Anwendungen: Spielen und anderen OpenGL-Apps, Tabellenkalkulationen und weiteren Office-Apps usw. Eigen 3 ist darauf ausgerichtet, mit GCC optimale Geschwindigkeit zu bieten. Seit der 2. Version von Eigen flossen viele Verbesserungen ein.

Die Bibliothek FFTW berechnet ein- oder mehrdimensionale schnelle Fourier-Transformationen (FFT). Sie ist extrem schnell. Dieses Paket enthält die statisch gelinkte Bibliothek, Header-Dateien und Testprogramme.

Dieses Paket enthält die Header-Dateien und statischen Bibliotheken. Die Dokumentation ist im Paket libfftw3-doc enthalten.

FLANN is a library for performing fast approximate nearest neighbor searches in high dimensional spaces. It contains a collection of algorithms found to work best for nearest neighbor search and a system for automatically choosing the best algorithm and optimum parameters depending on the dataset.

This package contains development files needed to build FLANN applications.

Die Fast Library for Integer Number Theory ist eine C-Bibliothek, die Polynomarithmetik über die ganzen Zahlen, schnelle Integer-Arithmetik und Faktorisierung (einschließlich eines hochoptimierten quadratischen Siebs) unterstützt.

FLINT hat eine ähnliche Funktionalität wie die Number Theory Library (NTL). Im Gegensatz zur NTL, die hauptsächlich für asymptotische Leistung ausgelegt ist, ist FLINT jedoch auch für gute Leistung in kleinen Fällen ausgelegt.

Dieses Paket enthält die FLINT-Entwicklungsdateien.

FpLLL ist eine Bibliothek zur Berechnung reduzierter (annähernd orthogonaler) Basen von euklidischen Gittern mittels LLL-Algorithmus.

FpLLL enthält mehrere unterschiedliche Implementierungen des Fließkomma-LLL-Reduktionsalgorithmus, mit unterschiedlichen Verhältnissen von Geschwindigkeit/Sicherheit.

Dieses Paket enthält einen Wrapper, welcher automatisch die bestbewertete Sequenz aus den Variationen auswählt, mit dem Ziel schnellstmöglich eine sichere Ausgabe zu liefern. Im Falle des Wrappers ist die Reihenfolge der Variationen für den Anwender nicht einsehbar.

Dieses Paket enthält Entwicklungsdateien für libfplll.

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 ist eine Sprache, die an partiell-differenzierbare Gleichungen (PDE) angepasst ist. Sie benutzt die Finite-Elemente-Methode. Diese Sprache wurde erfolgreich als Lehr- und Forschungswerkzeug eingesetzt.

Frobby is a software system and project for computations with monomial ideals. Frobby is free software and it is intended as a vehicle for computational and mathematical research on monomial ideals.

The current functionality includes Euler characteristic, Hilbert series, maximal standard monomials, combinatorial optimization on monomial ideals, primary decomposition, irreducible decomposition, Alexander dual, associated primes, minimization and intersection of monomial ideals as well as the computation of Frobenius problems (using 4ti2) with very large numbers. Frobby is also able to translate between formats that can be used with several different computer systems, such as Macaulay 2, Monos, 4ti2, CoCoA4 and Singular. Thus Frobby can be used with any of those systems.

This package contains the development tools.

This is not a full linear algebra library, only a GEMM library: it only does general matrix multiplication ("GEMM").

Its performance goals differ from typical GEMM performance goals in the following ways: 1. It cares not only about speed, but also about minimizing power usage.

   It specifically cares about charge usage in mobile/embedded devices.
2. Most GEMMs are optimized primarily for large dense matrix sizes (>= 1000).
   It does care about large sizes, but it also cares specifically about the
   typically smaller matrix sizes encountered in various mobile applications.

Keep in mind (previous section) that gemmlowp itself is a pure-headers-only library.

GF2X is a C/C++ software package containing routines for fast arithmetic in GF(2)[x] (multiplication, squaring, GCD) and searching for irreducible/primitive trinomials.

This package contains the development files for the library.

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.

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.

GLPK supports the GNU MathProg language, which is a subset of the AMPL language. GLPK also supports the standard MPS and LP formats.

This package contains the Java binding to GLPK.

This interface allows gnuplot to be controlled from C++ and is designed to be the lowest hanging fruit. In other words, if you know how gnuplot works it should only take 30 seconds to learn this library. Basically it is just an iostream pipe to gnuplot with some extra functions for pushing data arrays and getting mouse clicks. Data sources include STL containers (eg. vector or map) and one or two dimensional Blitz++ arrays (of scalars or TinyVectors). Support for other data sources should be easy to add.

Basically there are two functions defined: send() sends arrays of data values (it is overloaded to do the right thing based upon what type of variable you pass) and getMouse() gets the position of a mouse click. Everything else is accomplished by sending commands manually to gnuplot via the iostream interface.

libhomfly is a library to compute the homfly polynomial of knots and links.

It is based on a program written by Robert J Jenkins Jr.

This package contains the development files for the library.

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.

igraph is a library for creating and manipulating graphs. It is intended to be as powerful (ie. fast) as possible to enable the analysis of large graphs.

This package contains the include files and static library for igraph.

IML is a library for exact, dense linear algebra over the integers. IML contains algorithms for nonsingular rational system solving, computing the right nullspace of an integer matrix, and certified linear system solving.

In addition, IML provides some low level routines for a variety of mod p matrix operations: computing the row-echelon form, determinant, rank profile, and inverse of a mod p matrix. These mod p routines are not general purpose; they require that p satisfy some preconditions based on the dimension of the input matrix (usually p should be prime and should be no more than about 20 bits long).

This package contains development files for IML.

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 implementations 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.

JGraphT is a free Java graph library that provides mathematical graph theory objects and algorithms. JGraphT supports various types of graphs including:

• directed and undirected graphs
• graphs with weighted, unweighted, labeled or user-defined edges
• various edge multiplicity options, including simple graphs, multigraphs and pseudographs
• unmodifiable graphs: allow modules to provide "read-only" access to internal graphs
• listenable graphs: allow external listeners to track modification events
• subgraphs: graphs that are auto-updating subgraph views on other graphs

JGraphT is a free Java graph library that provides mathematical graph theory objects and algorithms. JGraphT supports various types of graphs including:

• directed and undirected graphs;
• graphs with weighted, unweighted, labeled or user-defined edges;
• various edge multiplicity options, including simple graphs, multigraphs and pseudographs;
• unmodifiable graphs: allow modules to provide "read-only" access to internal graphs;
• listenable graphs: allow external listeners to track modification events;
• subgraphs: graphs that are auto-updating subgraph views on other graphs;
• all compositions of above graphs.

JGraphT is designed to be simple and type-safe (via Java generics): graph vertices can be of any objects: Strings, URLs, XML documents, even graphs themselves.

LAPACK in der Version 3.0 ist eine umfassende FORTRAN-Bibliothek für Operationen der linearen Algebra, wie z.B. Matrizeninvertierung, Lösung von linearen Gleichungssystemen mit der Methode der kleinsten Quadrate, Eigenwertanalyse, Singulärwertzerlegung usw. Es ist ein sehr umfassendes und angesehenes Paket, das umfangreiche Verwendung in der wissenschaftlichen Gemeinschaft gefunden hat.

Dieses Paket enthält eine statische Version der Bibliothek.

Solves nonlinear optimization problems using the limited-memory BFGS method. The user specifies a callback C function that returns the value and gradients of the cost function at a particular operating point. This library estimates the Hessians from user input, and applies Newton's method iteratively to find a local minimum of the cost function. This is a small library, written in C with minimal dependencies.

This package contains development files

Lcalc ist eine Bibliothek zum Berechnen von Nullstellen und Werten von L-Funktionen. Im Leistungsumfang befinden sich die L-Funktionen der Riemannschen Zeta-Funktion, der Ramanujan-Delta-Funktion und von elliptischen Kurven über die rationalen Zahlen.

Dieses Paket enthält die Entwicklungsdateien für die Bibliothek.

LinBox is a C++ template library for exact, high-performance linear algebra computation with dense, sparse, and structured matrices over the integers and over finite fields.

This package contains the LinBox development files.

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.

Der »Littlewood-Richardson Calculator« ist ein Paket, bestehend aus C-Programmen, zur Berechnung von Littlewood-Richardson-Koeffizienten. Es ermöglicht eine schnelle Berechnung einzelner LR-Koeffizienten, Produkten von Schur-Funktionen und schiefer Schur-Funktionen. Die Schnittstelle nutzt die gleiche Notation wie das SF-Paket von John Stembridge, um eine gleichzeitige Verwendung beider Pakete zu vereinfachen.

Dieses Paket enthält die Entwicklungsdateien für die Bibliothek.

M4RI is a library for fast arithmetic with dense matrices over F2. The name M4RI comes from the first implemented algorithm: The "Method of the Four Russians" inversion algorithm. This algorithm in turn is named after the "Method of the Four Russians" multiplication algorithm which is probably better referred to as Kronrod's method.

This package contains development files for libm4ri.

M4RIE is a library for fast arithmetic with dense matrices over small finite fields of even characteristic. It uses the M4RI library, implementing the same operations over the finite field F2.

The name M4RI comes from the first implemented algorithm: The "Method of the Four Russians" inversion algorithm. This algorithm in turn is named after the "Method of the Four Russians" multiplication algorithm which is probably better referred to as Kronrod's method.

This package contains development files for the M4RIE library.

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.

Mathic is a C++ library of fast data structures designed for use in Groebner basis computation. This includes data structures for ordering S-pairs, performing divisor queries and ordering polynomial terms during polynomial reduction.

This package contains the developer tools.

Mathicgb is a program for computing Groebner basis and signature Groebner bases. Mathicgb is based on the fast data structures from mathic.

The paper "Practical Groebner Basis Computation" describes the algorithms in Mathicgb from a high level. It was presented at ISSAC 2012 and is available at http://arxiv.org/abs/1206.6940

This package contains the developer tools.

matio is a C library for reading and writing MATLAB MAT files.

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

This package provides a C library of functions for interval arithmetic computations with arbitrary precision.

The basic principle of interval arithmetic consists in enclosing every number by an interval containing it and being representable by machine numbers: for instance it can be stored as its lower and upper endpoints and these bounds are machine numbers, or as a centre and a radius which are machine numbers.

The arithmetic operations are extended for interval operands in such a way that the exact result of the operation belongs to the computed interval.

The purpose of an arbitrary precision interval arithmetic is on the one hand to get guaranteed results, thanks to interval computation, and on the other hand to obtain accurate results, thanks to multiple precision arithmetic. The MPFI library is built upon MPFR in order to benefit from the correct roundings provided by MPFR. Further advantages of using MPFR are its portability and compliance with the IEEE 754 standard for floating-point arithmetic.

This package provides the static library and symbolic links needed for development.

MPFR C++ introduces C++ arbitrary precision numeric types; based on GNU MPFR --- Multiple Precision Floating-Point Reliable Library.

MPFR C++ makes possible to use MPFR calculations in the same simple way as calculations with numbers of built-in types double or float: all arithmetic and boolean operators (+, -, *, /, >, !=, etc.) are implemented through operator overloading technique; elementary mathematical functions (sqrt, pow, sin, cos, etc.) are supported.

A polynomial rootfinder that can determine arbitrary precision approximations with guaranteed inclusion radii. It supports exploiting of polynomial structures such as sparsisty and allows for polynomial implicitly defined or in some non standard basis.

This package contains the development headers and the .so library of MPSolve.

MuParser ist eine in (reinem) C++ geschriebene, sehr leistungsstarke Bibliothek für die Auswertung mathematischer Ausdrücke. Sie beruht auf der Überführung eines Ausdrucks in einen Bytecode und der vorausschauenden Berechnung von konstanten Teilausdrücken.

Dieses Paket enthält die Entwicklungsdateien.

Die Newmat-Bibliothek wendet sich an Wissenschaftler und Ingenieure, die eine Vielzahl von Matrizentypen mit Matrix-Standardoperationen manipulieren müssen. Schwerpunkt liegt auf Operationen derart, wie sie in statistischen Berechnungen wie der Methode der kleinsten Quadrate, linearen Gleichungssystemen und Eigenwerte benötigt werden.

Newmat unterstützt folgende Matrizentypen: Matrix (Rechtecksmatrix); UpperTriangularMatrix; LowerTriangularMatrix; DiagonalMatrix; SymmetricMatrix; BandMatrix; UpperBandMatrix; LowerBandMatrix; SymmetricBandMatrix; IdentityMatrix; RowVector; ColumnVector.

Nur ein Elementtyp (float oder double) wird unterstützt (Standard ist double).

Diese Bibliothek enthält die Operationen , +, -, =, +=, -=, Kronecker- Produkt, Schurkomplement, Konkatenation, Invers, transponieren, Umwandlung zwischen Typen, Teilmatrix, Deterministische, Cholesky-Zerlegung, QR- Triangularisierung, Singulärwertzerlegung, Eigenwert einer symmetrischen Matrix, sortieren, Schnelle Fourier- und trig. Transformationen und Ausgabe.

Libnewmat-dev enthält statische Bibliotheken, Header-Dateien und etwas Dokumentation.

NFFT3 is a software library written in C for computing nonequispaced fast Fourier and related transformations. In detail, NFFT3 implements:

1) The nonequispaced fast Fourier transform (NFFT)

• the forward transform (NFFT)
• the adjoint transform (adjoint NFFT)

2) Generalisations of the NFFT

• to arbitrary knots in time and frequency domain (NNFFT)
• to the sphere S^2 (NFSFT)
• to the hyperbolic cross (NSFFT)
• to real-valued data, i.e. (co)sine transforms, (NFCT, NFST)
• to the rotation group (NFSOFT)

3) Generalised inverses based on iterative methods, e.g. CGNR, CGNE

4) Applications in

• medical imaging (i) magnetic resonance imaging (ii) computerised tomography
• summation schemes (i) fast Gauss transform (FGT) (ii) singular kernels (iii) zonal kernels
• polar FFT, discrete Radon transform, ridgelet transform

This package provides the development files for the NFFT library.

NETGEN erzeugt automatisch 3D-Tetraedergitter. Es akzeptiert geometrisch-konstruktive (constructive solid geometry, CSG) oder durch Grenzflächen bestimmte (boundary representation, BRep) Eingaben im STL-Format. Die Verbindung zu einem Geometriekern ermöglicht die Behandlung von IGES- und STEP-Dateien. NETGEN beinhaltet Module zur Optimierung und hierarchischen Verfeinerung der Gitter.

Dieses Paket enthält die statischen Bibliotheken und Header-Dateien.

OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.

On amd64, arm64, i386, loong64, ppc64el, riscv64 and s390x, all kernels are included in the library and the one matching best your processor is selected at runtime.

On other architectures, for maximum performance, you may want to rebuild OpenBLAS locally, see the section: “Building an optimized OpenBLAS package for your machine” in README.Debian.

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