msolve is a C library implementing computer algebra algorithms for solving polynomial systems (with rational coefficients or coefficients in a prime field).

Currently, with msolve, you can basically solve multivariate polynomial systems. This encompasses:

• the computation of Groebner bases

• real root isolation of the solutions to polynomial systems

• the computation of the dimension and the degree of the solution set.

The CMH software computes Igusa (genus 2) class polynomials, which parameterize the CM points in the moduli space of 2-dimensional abelian varieties, i.e. Jacobians of hyperelliptic curves. It can also be used to compute theta constants at arbitrary precision.

PARI/GP is a widely used computer algebra system designed for fast computations in number theory (factorisations, algebraic number theory, elliptic curves...), but it also contains a large number of other useful functions to compute with mathematical entities such as matrices, polynomials, power series, algebraic numbers, etc., and a lot of transcendental functions. PARI is also available as a C library to allow for faster computations.

GP2C, the GP to C compiler, translates GP scripts to PARI programs.

PyNormaliz provides an interface to Normaliz via libNormaliz. It offers the complete functionality of Normaliz, and can be used interactively from Python.

JLargeArrays is a Java library of one-dimensional arrays that can store up to 263 elements.

xtensor is a C++ library meant for numerical analysis with multi-dimensional array expressions.

xtensor provides:

• an extensible expression system enabling lazy broadcasting.

• an API following the idioms of the C++ standard library.

• tools to manipulate array expressions and build upon xtensor.

This package provides a simple Python interface to the Singular computer algebra system.

Spectra stands for Sparse Eigenvalue Computation Toolkit as a Redesigned ARPACK. It is a C++ library for large scale eigenvalue problems, built on top of Eigen. It is implemented as a header-only C++ library and can be easily embedded in C++ projects that require calculating eigenvalues of large matrices.

IML is a C library implementing algorithms for computing exact solutions to dense systems of linear equations over the integers. Currently, IML provides the following functionality:

• Nonsingular rational system solving: compute the unique rational solution X to the system AX=B, where A and B are integer matrices, A nonsingular.

• Compute the right nullspace or kernel of an integer matrix.

• Certified linear system solving: compute a minimal denominator solution x to a system Ax=b, where b is an integer vector and A is an integer matrix with arbitrary shape and rank profile.

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

Gappa is a tool intended to help verifying and formally proving properties on numerical programs dealing with floating-point or fixed-point arithmetic. It has been used to write robust floating-point filters for CGAL and it is used to certify elementary functions in CRlibm. While Gappa is intended to be used directly, it can also act as a backend prover for the Why3 software verification platform or as an automatic tactic for the Coq proof assistant.

This package provides a Python wrapper for Fourier Local Correlation Tracking.

FORM is a symbolic manipulation system. It reads symbolic expressions from files and executes symbolic/algebraic transformations upon them. The answers are returned in a textual mathematical representation. The size of the considered expressions in FORM is only limited by the available disk space and not by the available RAM. This package also includes parform, a version of FORM parallelized using OpenMPI.

NTL is a C++ library providing data structures and algorithms for manipulating signed, arbitrary length integers, and for vectors, matrices, and polynomials over the integers and over finite fields.

Kiss FFT is a mixed-radix Fast Fourier Transform based up on the principle, 'Keep It Simple, Stupid.'

The Littlewood-Richardson Calculator (lrcalc) is a program designed to compute Littlewood-Richardson coefficients. It computes single Littlewood-Richardson coefficients, products of Schur functions, or skew Schur functions. In addition it computes products in the small quantum cohomology ring of a Grassmann variety. The software package also includes a program that performs fast computation of the more general multiplicative structure constants of Schubert polynomials.

FLINT is a C library for number theory. It supports arithmetic with numbers, polynomials, power series and matrices over many base rings, including multiprecision integers and rationals, integers modulo n, p-adic numbers, finite fields (prime and non-prime order) and real and complex numbers (via the Arb extension library).

Operations that can be performed include conversions, arithmetic, GCDs, factoring, solving linear systems, and evaluating special functions. In addition, FLINT provides various low-level routines for fast arithmetic.

Normaliz is a tool for computations in affine monoids, vector configurations, rational polyhedra and rational cones. Normaliz now computes rational and algebraic polyhedra, i.e., polyhedra defined over real algebraic extensions of QQ.

REDUCE is a portable general-purpose computer algebra system. It is a system for doing scalar, vector and matrix algebra by computer, which also supports arbitrary precision numerical approximation and interfaces to gnuplot to provide graphics. It can be used interactively for simple calculations but also provides a full programming language, with a syntax similar to other modern programming languages. REDUCE supports alternative user interfaces including Run-REDUCE, TeXmacs and GNU Emacs. This package provides the Codemist Standard Lisp (CSL) version of REDUCE. It uses the gnuplot program, if installed, to draw figures.

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

PariTwine is a glue library between the system for computer algebra and number theory PARI/GP and a number of other mathematics libraries, currently GMP, GNU MPFR, GNU MPC, FLINT and CMH.

fplll contains implementations of several lattice algorithms. The implementation relies on floating-point orthogonalization, and LLL is central to the code, hence the name.

It includes implementations of floating-point LLL reduction algorithms, offering different speed/guarantees ratios. It contains a wrapper choosing the estimated best sequence of variants in order to provide a guaranteed output as fast as possible. In the case of the wrapper, the succession of variants is oblivious to the user.

It includes an implementation of the BKZ reduction algorithm, including the BKZ-2.0 improvements (extreme enumeration pruning, pre-processing of blocks, early termination). Additionally, Slide reduction and self dual BKZ are supported.

It also includes a floating-point implementation of the Kannan-Fincke-Pohst algorithm that finds a shortest non-zero lattice vector. For the same task, the GaussSieve algorithm is also available in fplll. Finally, it contains a variant of the enumeration algorithm that computes a lattice vector closest to a given vector belonging to the real span of the lattice.

The eclib package includes mwrank (for 2-descent on elliptic curves over Q) and modular symbol code; it has been written by John Cremona to compute his elliptic curve database.

FLINT is a C library for number theory. It supports arithmetic with numbers, polynomials, power series and matrices over many base rings, including multiprecision integers and rationals, integers modulo n, p-adic numbers, finite fields (prime and non-prime order) and real and complex numbers (via the Arb extension library).

Operations that can be performed include conversions, arithmetic, GCDs, factoring, solving linear systems, and evaluating special functions. In addition, FLINT provides various low-level routines for fast arithmetic.

This library provides a Python wrapper to SymEngine, a fast C++ symbolic manipulation library.