# All Classes and Interfaces

Class

Description

Absolute value function.

Base class for all convergence checker implementations.

Base class that contains common code for fitting parametric univariate
real functions

`y = f(p`_{i};x)

, where `x`

is
the independent variable and the `p`_{i}

are the
*parameters*.Vector function for computing function theoretical values.

An implementation of

`LeastSquaresProblem.Evaluation`

that is designed for extension.Base class managing common boilerplate for all integrators.

Basic implementation of

`FieldMatrix`

methods regardless of the underlying storage.Base class for #@link

`FieldODEEventDetector`

.This abstract class represents an interpolator over the last step
during an ODE integration.

Base class for integer-valued discrete distributions.

Base class managing common boilerplate for all integrators.

Shared parts between linear and non-linear Kalman filters.

Abstract base class for implementations of MultipleLinearRegression.

Base class for multivariate probability distributions.

Base class for #@link

`ODEEventDetector`

.This abstract class represents an interpolator over the last step
during an ODE integration.

Base class for open addressed map from int.

Holder for handling values insertion.

Interface for copying values.

Base class for implementing optimization problems.

This abstract class provides boilerplate parameters list.

Base class for solvers.

Base class for probability distributions on the reals.

Basic implementation of RealMatrix methods regardless of the underlying storage.

Abstract class for all regions, independently of geometry type or dimension.

Base class for rules that determines the integration nodes and their
weights.

This class implements the simplex concept.

Abstract class for Sequential Quadratic Programming solvers

Abstract base class for implementations of the

`StorelessUnivariateStatistic`

interface.This class implements the dimension-independent parts of

`SubHyperplane`

.Provide a default implementation for several functions useful to generic
solvers.

Base class for solvers.

Abstract base class for implementations of the

`UnivariateStatistic`

interface.Base class for unscented transform providers.

This abstract class implements the WELL class of pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

Inner class used to store the indirection index table which is fixed
for a given type of WELL class of pseudo-random number generator.

Arc-cosine function.

Hyperbolic arc-cosine function.

Enumerate for actions to be performed when an event occurs during ODE integration.

This class implements explicit Adams-Bashforth integrators for Ordinary
Differential Equations.

This class implements explicit Adams-Bashforth integrators for Ordinary
Differential Equations.

Base class for

`Adams-Bashforth`

and
`Adams-Moulton`

integrators.Base class for

`Adams-Bashforth`

and
`Adams-Moulton`

integrators.This class implements implicit Adams-Moulton integrators for Ordinary
Differential Equations.

This class implements implicit Adams-Moulton integrators for Ordinary
Differential Equations.

Transformer to Nordsieck vectors for Adams integrators.

Transformer to Nordsieck vectors for Adams integrators.

This interface represents an event checking interval that depends on state.

This abstract class holds the common part of all adaptive
stepsize integrators for Ordinary Differential Equations.

Add the two operands.

Convergence Checker for ADMM QP Optimizer.

Alternative Direction Method of Multipliers Solver.

TBD.

Alternating Direction Method of Multipliers Quadratic Programming Optimizer.

Container for

`ADMMQPOptimizer`

settings.Internal Solution for ADMM QP Optimizer.

An interface for statistics that can aggregate results.

Computes a cubic spline interpolation for the data set using the Akima
algorithm, as originally formulated by Hiroshi Akima in his 1970 paper
A New Method of
Interpolation and Smooth Curve Fitting Based on Local Procedures.
J.

A simple heuristic to improve the performance of convex hull algorithms.

The kinds of solutions that a

`(bracketed univariate real) root-finding algorithm`

may accept as solutions.Represents an alternative hypothesis for a hypothesis test.

Interface defining very basic matrix operations.

This class represents an arc on a circle.

This class represents a region of a circle: a set of arcs.

Specialized exception for inconsistent BSP tree state inconsistency.

Class holding the results of the

`split`

method.Some useful, arithmetics related, additions to the built-in functions in

`Math`

.Implementation of

`FieldMatrix`

using a `FieldElement`

[][] array to store entries.Implementation of

`RealMatrix`

using a `double[][]`

array to
store entries.This class implements the

`FieldVector`

interface with a `FieldElement`

array.This class implements the

`RealVector`

interface with a double array.Arc-sine function.

Hyperbolic arc-sine function.

Arc-tangent function.

Arc-tangent function.

Hyperbolic arc-tangent function.

Provide a default implementation for several generic functions.

Provide a default implementation for several generic functions.

Provide a default implementation for several functions useful to generic
solvers.

Base class multi-start optimizer for a multivariate function.

Base class for implementing optimizers for multivariate functions.

Base class for implementing optimizers.

Base class for all bracketing

*Secant*-based methods for root-finding (approximating a zero of a univariate real function).*Secant*-based root-finding methods.

Interface for (univariate real) rootfinding algorithms.

This class provides computation methods related to Bessel
functions of the first kind.

Encapsulates the results returned by

`BesselJ.rjBesl(double, double, int)`

.
This is a utility class that provides computation methods related to the
Beta family of functions.

Implements the Beta distribution.

Function that implements the
bicubic spline interpolation.

Generates a

```
bicubic interpolating
function
```

.Representation of a rational number without any overflow.

A test to determine if a series of fractions has converged.

Representation of the fractional numbers without any overflow field.

Formats a BigFraction number in proper format or improper format.

Arbitrary precision decimal number.

Representation of real numbers with arbitrary precision field.

Interpolate grid data using bi-linear interpolation.

Interpolate grid data using bi-linear interpolation.

This class wraps a

`double`

value in an object.The field of

`double precision floating-point numbers`

.Implementation of the binomial distribution.

Utility methods to generate confidence intervals for a binomial proportion.

Implements binomial test statistics.

Implements the
bisection algorithm for finding zeros of univariate real functions.

An interface representing a bivariate real function.

Interface representing a bivariate real interpolating function where the
sample points must be specified on a regular grid.

Interface representing classes that can blend with other instances of themselves using a given blending value.

Cache-friendly implementation of FieldMatrix using a flat arrays to store
square blocks of the matrix.

Cache-friendly implementation of RealMatrix using a flat arrays to store
square blocks of the matrix.

Powell's BOBYQA algorithm.

Class holding boundary attributes.

Class holding the result of point projection on region boundary.

Constraint with lower and upper bounds: \(l \le f(x) \le u\).

Interface for

```
(univariate real) root-finding
algorithms
```

that maintain a bracketed solution.An interval of a function that brackets a root.

Interface for

```
(univariate real) root-finding
algorithms
```

that maintain a bracketed solution.An interval of a function that brackets a root.

Provide an interval that brackets a local optimum of a function.

This class implements a modification of the Brent algorithm.

For a function defined on some interval

`(lo, hi)`

, this class
finds an approximation `x`

to the point at which the function
attains its minimum.This class implements the
Brent algorithm for finding zeros of real univariate functions.

This class represent a Binary Space Partition tree.

This interface gather the merging operations between a BSP tree
leaf and another BSP tree.

This interface handles the corner cases when an internal node cut sub-hyperplane vanishes.

This interface is used to visit

`BSP tree`

nodes.Enumerate for visit order with respect to plus sub-tree, minus sub-tree and cut sub-hyperplane.

This interface represents an integrator based on Butcher arrays.

An interface representing a bivariate field function.

Interface representing a field
with calculus capabilities (sin, cos, ...).

An interface representing a scalar multivariate function.

An interface representing a matrix multivariate function.

An interface representing a vector multivariate function.

An interface representing a univariate real function.

An interface representing a univariate matrix function.

An interface representing a univariate vectorial function for any field type.

Calculates the Canberra distance between two points.

Deprecated.

Elliptic integrals in Carlson symmetric form.

Implementation of the Cauchy distribution.

Cube root function.

`ceil`

function.A Cluster used by centroid-based clustering algorithms.

Calculates the L

_{∞}(max of abs) distance between two points.Implementation of the chi-squared distribution.

Implements Chi-Square test statistics.

Matrix decomposer using Cholseky decomposition.

Calculates the Cholesky decomposition of a matrix.

This class represents an oriented great circle on the 2-sphere.

This class implements the classical fourth order Runge-Kutta
integrator for Ordinary Differential Equations (it is the most
often used Runge-Kutta method).

Cluster holding a set of

`Clusterable`

points.Interface for n-dimensional points that can be clustered together.

Plots clustering results for various algorithms and datasets.

Plot component.

Display frame.

Base class for clustering algorithms.

Base class for cluster evaluation methods.

An implementation of the active Covariance Matrix Adaptation Evolution Strategy (CMA-ES)
for non-linear, non-convex, non-smooth, global function minimization.

Population size.

Input sigma values.

Utility to create combinations

`(n, k)`

of `k`

elements
in a set of `n`

elements.Combinatorial utilities.

Class for computing the natural logarithm of the factorial of

`n`

.Representation of a Complex number, i.e.

Comparator for Complex Numbers.

Given a matrix A, it computes a complex eigen decomposition AV = VD.

Representation of the complex numbers field.

Formats a Complex number in cartesian format "Re(c) + Im(c)i".

This class converts

```
complex Ordinary
Differential Equations
```

into `real ones`

.Container for time, main and secondary state vectors.

Container for time, main and secondary state vectors as well as their derivatives.

This interface represents a first order differential equations set for

`complex state`

.This interface allows users to add secondary differential equations to a primary
set of differential equations.

Wrapper to perform univariate complex integration using an underlying real integration algorithms.

Static implementations of common

`Complex`

utilities functions.Base class for formatters of composite objects (complex numbers, vectors ...).

Represents an interval estimate of a population parameter.

This is an implementation of the conjugate gradient method for

`RealLinearOperator`

.Constant function.

Implementation of the constant real distribution.

Generic constraint.

Abstract Constraint Optimizer.

Provides a generic means to evaluate continued fractions.

Classical method for domain coloring.

Deprecated.

as of 1.0, replaced with

`DenseOutputModel`

This interface specifies how to check if an optimization algorithm has
converged.

Multiplexer for

`ConvergenceChecker`

, checking *all*the checkers converged.Multiplexer for

`ConvergenceChecker`

, checking *one*of the checkers converged.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

This class represents a convex hull.

This class represents a convex hull in an two-dimensional euclidean space.

Interface for convex hull generators.

Interface for convex hull generators in the two-dimensional euclidean space.

Copolar trio with pole at point c in Glaisherâ€™s Notation.

Copolar trio with pole at point d in Glaisherâ€™s Notation.

Copolar trio with pole at point n in Glaisherâ€™s Notation.

Copolar trio with pole at point s in Glaisherâ€™s Notation.

A

`RandomVectorGenerator`

that generates vectors with with
correlated components.Cosine function.

Hyperbolic cosine function.

Computes covariances for pairs of arrays or columns of a matrix.

DBSCAN (density-based spatial clustering of applications with noise) algorithm.

This enumeration defines the various types of normalizations that can be
applied to discrete cosine transforms (DCT).

Interface handling decomposition algorithms that can solve A × X = B.

Default implementation of the

`FieldMatrixChangingVisitor`

interface.Default implementation of the

`FieldMatrixPreservingVisitor`

interface.A default concrete implementation of the abstract class

`IterativeLinearSolverEvent`

.Default implementation of the

`RealMatrixChangingVisitor`

interface.Default implementation of the

`RealMatrixPreservingVisitor`

interface.This class stores all information provided by an ODE integrator
during the integration process and build a continuous model of the
solution from this.

Enumerate to specify how dependent vectors should be handled in

`MatrixUtils.orthonormalize(List, double, DependentVectorsHandler)`

and
`MatrixUtils.orthonormalize(Field, List, CalculusFieldElement, DependentVectorsHandler)`

.Interface representing both the value and the differentials of a function.

Interface representing an object holding partial derivatives up to first order.

Class representing both the value and the differentials of a function.

Maintains a dataset of values of a single variable and computes descriptive
statistics based on stored data.

This class handles the state for one

`event handler`

during integration steps.Decimal floating point library for Java

Subclass of

`Dfp`

which hides the radix-10000 artifacts of the superclass.Field for Decimal floating point instances.

Enumerate for rounding modes.

Mathematical routines for use with

`Dfp`

.This enumeration defines the various types of normalizations that can be
applied to discrete Fourier transforms (DFT).

Implementation of a diagonal matrix.

Interface representing an object holding partial derivatives.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Class generating an enclosing ball from its support points.

Interface for distance measures of n-dimensional vectors.

Divide the first operand by the second.

Implements the
Divided Difference Algorithm for interpolation of real univariate
functions.

Base class for domain coloring.

This class implements the 5(4) Dormand-Prince integrator for Ordinary
Differential Equations.

This class implements the 5(4) Dormand-Prince integrator for Ordinary
Differential Equations.

This class implements the 8(5,3) Dormand-Prince integrator for Ordinary
Differential Equations.

This class implements the 8(5,3) Dormand-Prince integrator for Ordinary
Differential Equations.

A simple implementation of

`Clusterable`

for points with double coordinates.Class holding "compiled" computation rules for derivative structures.

Factory for

`DerivativeStructure`

.Field for {link DerivativeStructure} instances.

This enumeration defines the various types of normalizations that can be
applied to discrete sine transforms (DST).

Dummy implementation of the

`Localizable`

interface, without localization.Deprecated.

as of 1.0, this class is not used anymore

Calculates the Earh Mover's distance (also known as Wasserstein metric) between two distributions.

Spherical polygons boundary edge.

Calculates the eigen decomposition of a non-symmetric real matrix.

Calculates the eigen decomposition of a symmetric real matrix.

This class implements the common part of all embedded Runge-Kutta
integrators for Ordinary Differential Equations.

This interface defines mappers between a space and one of its sub-spaces.

Represents an
empirical probability distribution -- a probability distribution derived
from observed data without making any assumptions about the functional form
of the population distribution that the data come from.

Interface for algorithms computing enclosing balls.

This class represents a ball enclosing some points.

A generic implementation of a
discrete probability distribution (Wikipedia) over a finite sample space,
based on an enumerated list of <value, probability> pairs.

Implementation of an integer-valued

`EnumeratedDistribution`

.Implementation of a real-valued

`EnumeratedDistribution`

.Equality Constraint.

Class mapping the part of a complete state or derivative that pertains
to a specific differential equation.

This is a utility class that provides computation methods related to the
error functions.

This class implements a one-dimensional space.

Specialized exception for inexistent sub-space.

This class implements a two-dimensional space.

This class implements a three-dimensional space.

Calculates the L

_{2}(Euclidean) distance between two points.This class implements a simple Euler integrator for Ordinary
Differential Equations.

This class implements a simple Euler integrator for Ordinary
Differential Equations.

Check if an optimization has converged based on the change in computed RMS.

Deprecated.

as of 1.0, replaced with

`ODEEventDetector`

Deprecated.

as of 1.0, replaced with

`Action`

Class to hold the data related to an event occurrence that is needed to decide how
to modify integration.

Wrapper used to detect only increasing or decreasing events.

This interface handles the state for either one

`event handler`

or one `step end handler`

during integration steps.Graphics utilities for examples.

Display frame.

Exponential function.

This class represents a combined set of first order differential equations,
with at least a primary set of equations expandable by some sets of secondary
equations.

This interface implements the part of Runge-Kutta
integrators for Ordinary Differential Equations
common to fixed- and adaptive steps.

`e`^{x}-1

function.Implementation of the exponential distribution.

Kalman filter for

`non-linear process`

.Implements the Fast Cosine Transform for transformation of one-dimensional
real data sets.

Implements the Fast Fourier Transform for transformation of one-dimensional
real or complex data sets.

Implements the Fast Hadamard Transform (FHT).

Faster, more accurate, portable alternative to

`Math`

and
`StrictMath`

for large scale computation.Implements the Fast Sine Transform for transformation of one-dimensional real
data sets.

Implementation of the F-distribution.

Factory for

`FieldDerivativeStructure`

.Field for {link FieldDerivativeStructure} instances.

Interface representing a field.

Base class for rules that determines the integration nodes and their
weights.

This interface represents an event checking interval that depends on state.

An interface representing a bivariate field function.

This class implements a modification of the Brent algorithm.

This interface represents an integrator based on Butcher arrays.

Representation of a Complex number, i.e.

Representation of the complex numbers field.

Wrapper to perform univariate complex integration using an underlying real integration algorithms.

Provides a generic means to evaluate continued fractions.

Copolar trio with pole at point c in Glaisherâ€™s Notation.

Copolar trio with pole at point d in Glaisherâ€™s Notation.

Copolar trio with pole at point n in Glaisherâ€™s Notation.

Copolar trio with pole at point s in Glaisherâ€™s Notation.

Interface handling decomposition algorithms that can solve A × X = B.

Interface representing both the value and the differentials of a function.

Interface representing a Field object holding partial derivatives up to first order.

Class representing both the value and the differentials of a function.

This class handles the state for one

`event handler`

during integration steps.Interface representing field elements.

Class mapping the part of a complete state or derivative that pertains
to a set of differential equations.

Wrapper used to detect only increasing or decreasing events.

`event handler`

or one `step end handler`

during integration steps.This interface implements the part of Runge-Kutta
Field integrators for Ordinary Differential Equations
common to fixed- and adaptive steps.

Class that implements the Gaussian rule for

`integrating`

a weighted
function.Class that provides different ways to compute the nodes and weights to be
used by the

`Gaussian integration rule`

.Class representing both the value and the differentials of a function.

Field for

`Gradient`

instances.Polynomial interpolator using both sample values and sample derivatives.

Factory that creates a
Gauss-type quadrature rule using Hermite polynomials
of the first kind.

Computation of Jacobi elliptic functions.

Algorithm computing Jacobi theta functions.

Factory that creates Gauss-type quadrature rule using Laguerre polynomials.

Factory that creates Gauss-type quadrature rule using Legendre polynomials.

The class represent lines in a three dimensional space.

Matrix decomposer using LU-decomposition.

Calculates the LUP-decomposition of a square matrix.

Interface defining field-valued matrix with basic algebraic operations.

Interface defining a visitor for matrix entries.

Interface for all algorithms providing matrix decomposition.

Interface defining a visitor for matrix entries.

Implements the
Midpoint Rule for integration of real univariate functions.

An interface representing a scalar multivariate function for any field type.

An interface representing a matrix multivariate function for any field type.

An interface representing a vector multivariate function for any field type.

This interface represents a handler for discrete events triggered
during ODE integration.

This interface represents a handler for discrete events triggered
during ODE integration.

This interface represents a handler that should be called after
each successful fixed step.

This interface represents a first order integrator for
differential equations.

Container for time, main and secondary state vectors.

Container for time, main and secondary state vectors as well as their derivatives.

This interface represents an interpolator over the last step
during an ODE integration.

This interface represents a handler for discrete events triggered
during ODE integration at each step end.

This interface represents a handler that should be called after
each successful step.

This interface represents a first order differential equations set.

Immutable representation of a real polynomial function with real coefficients.

Represents a polynomial spline function.

Matrix decomposer using QR-decomposition.

Calculates the QR-decomposition of a field matrix.

Implements the
Romberg Algorithm for integration of real univariate functions.

This class is a re-implementation of

`Rotation`

using `CalculusFieldElement`

.Interface for rules that determines the integration nodes and their weights.

Implements
Simpson's Rule for integration of real univariate functions.

Holder for both sine and cosine values.

Holder for both hyperbolic sine and hyperbolic cosine values.

This class handles the state for one

`event handler`

that triggers at step end.This class wraps an object implementing

`FieldODEFixedStepHandler`

into a `FieldODEStepHandler`

.Container for a Taylor map.

Values of

`Jacobi theta`

functions.Implements the
Trapezoid Rule for integration of real univariate functions.

This class allows to perform the same computation of all components of a Tuple at once.

FieldUnivariateDerivative<S extends CalculusFieldElement<S>,T extends FieldUnivariateDerivative<S,T>>

Abstract class representing both the value and the differentials of a function.

Class representing both the value and the differentials of a function.

Field for

`FieldUnivariateDerivative1`

instances.Class representing both the value and the differentials of a function.

Field for

`FieldUnivariateDerivative2`

instances.An interface representing a univariate real function for any field type.

Interface for univariate real integration algorithms.

Interface representing a univariate field interpolating function.

An interface representing a univariate matrix function for any field type.

An interface representing a univariate vectorial function for any field type.

Interface defining a field-valued vector with basic algebraic operations.

This class is a re-implementation of

`Vector2D`

using `CalculusFieldElement`

.This class is a re-implementation of

`Vector3D`

using `CalculusFieldElement`

.This interface defines a visitor for the entries of a vector.

This interface defines a visitor for the entries of a vector.

Enumerate for

`filtering events`

.Univariate functions differentiator using finite differences.

This class converts second order differential equations to first
order ones.

Deprecated.

as of 1.0, replaced with

`OrdinaryDifferentialEquation`

Deprecated.

as of 1.0, replaced with

`ODEFixedStepHandler`

`floor`

function.Representation of a rational number.

A test to determine if a series of fractions has converged.

Representation of the fractional numbers field.

Formats a Fraction number in proper format or improper format.

Maintains a frequency distribution of Comparable values.

Utilities for manipulating function objects.

Fuzzy K-Means clustering algorithm.

This is a utility class that provides computation methods related to the
Γ (Gamma) family of functions.

Implementation of the Gamma distribution.

Gaussian function.

Parametric function where the input array contains the parameters of
the Gaussian, ordered as follows:
Norm
Mean
Standard deviation

Fits points to a

`Gaussian`

function.Guesses the parameters

`norm`

, `mean`

, and `sigma`

of a `Gaussian.Parametric`

based on the specified observed points.This class is a gaussian normalized random generator for scalars.

Class that implements the Gaussian rule for

`integrating`

a weighted
function.`Gaussian integration rule`

.This class is a Gauss-Markov order 1 autoregressive process generator for scalars.

Gauss-Newton least-squares solver.

Implementation of the geometric distribution.

Returns the
geometric mean of the available values.

Simple example illustrating some parts of the geometry package.

Main frame for geometry examples.

This class implements the Gill fourth order Runge-Kutta
integrator for Ordinary Differential Equations .

The GLS implementation of multiple linear regression.

Program plotting complex functions with domain coloring.

Goal type for an optimization problem (minimization or maximization of
a scalar function.

Class representing both the value and the differentials of a function.

Field for

`Gradient`

instances.Class representing the gradient of a multivariate function.

Base class for implementing optimizers for multivariate scalar
differentiable functions.

This class implements a Gragg-Bulirsch-Stoer integrator for
Ordinary Differential Equations.

Helper for finding interpolation nodes along one axis of grid data.

Implements G Test
statistics.

This class implements the Gumbel distribution.

Implementation of a Halton sequence.

Fits points to a

`harmonic oscillator`

function.This class guesses harmonic coefficients from a sample.

simple harmonic oscillator function.

Parametric function where the input array contains the parameters of
the harmonic oscillator function, ordered as follows:
Amplitude
Angular frequency
Phase

Polynomial interpolator using both sample values and sample derivatives.

Factory that creates a
Gauss-type quadrature rule using Hermite polynomials
of the first kind.

Class transforming a general real matrix to Hessenberg form.

This class implements the 5(4) Higham and Hall integrator for
Ordinary Differential Equations.

This class implements the 5(4) Higham and Hall integrator for
Ordinary Differential Equations.

Implementation of the hypergeometric distribution.

This interface represents an hyperplane of a space.

Identity function.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Implements the

*Illinois*method for root-finding (approximating a zero of a univariate real function).This example shows how clustering can be applied to images.

Main frame for displaying clusters.

Utility that increments a counter until a maximum is reached, at
which point, the instance will by default throw a

`MathIllegalStateException`

.Defines a method to be called at counter exhaustion.

Inequality Constraint with lower bound only: \(l \le f(x)\).

A collection of static methods to create inference test instances or to
perform inference tests.

Starting point (first guess) of the optimization procedure.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Interface for discrete distributions.

Displays pdf/cdf for integer distributions.

Main frame for displaying distributions.

Utility class for the

`MicrosphereProjectionInterpolator`

algorithm.Utility class for the

`MicrosphereProjectionInterpolator`

algorithm.This class represents a 1D interval.

This class represents a 1D region: a set of intervals.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Inverse function.

A fast cryptographic pseudo-random number generator.

The root class from which all events occurring while running an

`IterationManager`

should be derived.The listener interface for receiving events occurring in an iterative
algorithm.

This abstract class provides a general framework for managing iterative
algorithms.

This algorithm divides the integration interval into equally-sized
sub-interval and on each of them performs a
Legendre-Gauss quadrature.

This abstract class defines an iterative solver for the linear system A
· x = b.

This is the base class for all events occurring during the iterations of a

`IterativeLinearSolver`

.Class representing the Jacobian of a multivariate vector function.

Deprecated.

as of 1.0, replaced with

`VariationalEquation`

Special exception for equations mismatch.

Algorithm computing Jacobi elliptic functions.

Builder for algorithms compmuting Jacobi elliptic functions.

Class for handling Jacobi polynomials keys.

This class implements the standard Jacobi (diagonal) preconditioner.

Algorithm computing Jacobi theta functions.

A

`RandomGenerator`

adapter that delegates the random number
generation to the standard `Random`

class.Unscented transform as defined by Julier and Uhlmann.

Interface representing a Kalman filter.

Karushâ€“Kuhnâ€“Tucker Solver.

Implementation of Kendall's Tau-b rank correlation.

Clustering algorithm based on David Arthur and Sergei Vassilvitski k-means++ algorithm.

Strategies to use for replacing an empty cluster.

Implementation of the
Kolmogorov-Smirnov (K-S) test for equality of continuous distributions.

A Simple K

^{th}selector implementation to pick up the K^{th}ordered element from a work array containing the input numbers.Computes the Kurtosis of the available values.

Container for Lagrange t-uple.

Factory that creates Gauss-type quadrature rule using Laguerre polynomials.

Implements the
Laguerre's Method for root finding of real coefficient polynomials.

This class implements the Laplace distribution.

An adapter that delegates to another implementation of

`LeastSquaresProblem`

.A mutable builder for

`LeastSquaresProblem`

s.This class converts

`vectorial objective functions`

to
`scalar objective functions`

when the goal is to minimize them.A Factory for creating

`LeastSquaresProblem`

s.An algorithm that can be applied to a non-linear least squares problem.

The optimum found by the optimizer.

The data necessary to define a non-linear least squares problem.

An evaluation of a

`LeastSquaresProblem`

at a particular point.Complete and incomplete elliptic integrals in Legendre form.

Factory that creates Gauss-type quadrature rule using Legendre polynomials.

This class solves a least-squares problem using the Levenberg-Marquardt
algorithm.

This class implements the
Lévy distribution.

This class represents a 1D oriented hyperplane on the circle.

The class represent lines in a three dimensional space.

This class represents an oriented line in the 2D plane.

A set of linear inequality constraints expressed as ub>Ax>lb.

A linear constraint for a linear optimization problem.

Class that represents a set of

`linear constraints`

.A set of linear equality constraints given as Ax = b.

Container for

`linear process`

evolution data.Set of linear inequality constraints expressed as \( A x \gt B\).

Implements a linear function for interpolation of real univariate functions.

Kalman filter for

`linear process`

.An objective function for a linear optimization problem.

Base class for implementing linear optimizers.

Linear process that can be estimated by a

`LinearKalmanFilter`

.Class for finding the minimum of the objective function along a given
direction.

Interface for localizable strings.

Enumeration for localized messages formats used in exceptions messages.

Enumeration for localized messages formats used in exceptions messages.

This interface specified methods implemented by localized exception classes.

Enumeration for localized messages formats used in exceptions messages.

Deprecated.

this class is only meant as a migration help from Apache Commons Math,
it is really replaced by

`LocalizedCoreFormats`

,
`LocalizedGeometryFormats`

, `LocalizedODEFormats`

,
`LocalizedOptimFormats`

and `LocalizedFFTFormats`

Enumeration for localized messages formats used in exceptions messages.

Deprecated.

these formats are not used at all, they are intended only
as a migration help from Apache Commons Math

Enumeration for localized messages formats used in exceptions messages.

Enumeration for localized messages formats used in exceptions messages.

Enumeration for localized messages formats used in exceptions messages.

Implements the
Local Regression Algorithm (also Loess, Lowess) for interpolation of
real univariate functions.

Natural logarithm function.

Base 10 logarithm function.

`log(1 + p)`

function.
Generalised logistic function.

Parametric function where the input array contains the parameters of
the

`logistic function`

, ordered as follows:
k
m
b
q
a
n
This class implements the Logistic distribution.

Logit function.

Parametric function where the input array contains the parameters of
the logit function, ordered as follows:
Lower bound
Higher bound

Implementation of the log-normal (gaussian) distribution.

Maintains a frequency distribution of Long values.

Plots 2D samples drawn from various pseudo / quasi-random generators.

Main frame for displaying low discrepancy points.

Plotting component.

Matrix decomposer using LU-decomposition.

Calculates the LUP-decomposition of a square matrix.

This class implements the Luther sixth order Runge-Kutta
integrator for Ordinary Differential Equations.

Deprecated.

as of 1.0, replaced with

`ODEJacobiansProvider`

Calculates the L

_{1}(sum of abs) distance between two points.An implementation of the Mann-Whitney U test.

Deprecated.

as of 1.0, replaced with

`MathRuntimeException`

Arrays utilities.

Real-valued function that operates on an array or a part of it.

Specification of ordering direction.

Specification for indicating that some operation applies
before or after a given index.

Base class for all preconditions violation exceptions.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Base class for all exceptions that signal that the process
throwing the exception is in a state that does not comply with
the set of states that it is designed to be in.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

All exceptions thrown by the Hipparchus code inherit from this class.

Deprecated.

as of 1.0, replaced with

`MathRuntimeException`

Miscellaneous utility functions.

Result class for

`MathUtils.twoSum(FieldElement, FieldElement)`

containing
the sum and the residual error in the sum.Result class for

`MathUtils.twoSum(double, double)`

containing the
sum and the residual error in the sum.Interface for all algorithms providing matrix decomposition.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

A collection of static methods that operate on or return matrices.

Maximum function.

Returns the maximum of the available values.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Maximum number of evaluations of the function to be optimized.

Maximum number of iterations performed by an (iterative) algorithm.

Computes the arithmetic mean of a set of values.

Interface defining a measurement on process.

Returns the median of the available values.

This class implements a powerful pseudo-random number generator
developed by Makoto Matsumoto and Takuji Nishimura during
1996-1997.

Unscented transform as defined by Merwe and Wan.

Interpolator that implements the algorithm described in

*William Dudziak*'s MS thesis.This class implements a second order Runge-Kutta integrator for
Ordinary Differential Equations.

This class implements a second order Runge-Kutta integrator for
Ordinary Differential Equations.

Implements the
Midpoint Rule for integration of real univariate functions.

This class is a concrete implementation of the

`UpdatingMultipleLinearRegression`

interface.Minimum function.

Returns the minimum of the available values.

Minus function.

Multivariate normal mixture distribution.

Class for representing
mixture model distributions.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Implements Andrew's monotone chain method to generate the convex hull of a finite set of
points in the two-dimensional euclidean space.

This class implements the
Muller's Method for root finding of real univariate functions.

This class implements the
Muller's Method for root finding of real univariate functions.

Converter between unidimensional storage structure and multidimensional
conceptual structure.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

This class implements the multi-directional direct search method.

A wrapper around a k-means++ clustering algorithm which performs multiple trials
and returns the best solution.

The multiple linear regression can be represented in matrix-notation.

Multiply the two operands.

Multi-start optimizer.

Special implementation of the

`UnivariateOptimizer`

interface
adding multi-start features to an existing optimizer.This class is the base class for multistep integrators for Ordinary
Differential Equations.

This class is the base class for multistep integrators for Ordinary
Differential Equations.

Extension of

`MultivariateFunction`

representing a
multivariate differentiable real function.Extension of

`MultivariateVectorFunction`

representing a
multivariate differentiable vectorial function.An interface representing a multivariate real function.

Adapter for mapping bounded

`MultivariateFunction`

to unbounded ones.Adapter extending bounded

`MultivariateFunction`

to an unbouded
domain using a penalty function.Interface representing a univariate real interpolating function.

A interface for functions that compute a vector of values and can compute their
derivatives (Jacobian).

An interface representing a multivariate matrix function.

Implementation of the multivariate normal (Gaussian) distribution.

Expectation-Maximization algorithm for fitting the parameters of
multivariate normal mixture model distributions.

Base class for a multivariate scalar function optimizer.

Base interface for multivariate continuous distributions.

Computes summary statistics for a stream of n-tuples added using the

`addValue`

method.An interface representing a multivariate vectorial function.

This class implements the Nakagami distribution.

Interface to compute exactly Jacobian matrix for some parameter
when computing

`partial derivatives equations`

.Strategies for handling NaN values in rank transformations.

Ranking based on the natural ordering on doubles.

This class implements the Nelder-Mead simplex algorithm.

Implements the
Neville's Algorithm for interpolation of real univariate functions.

Implements
Newton's Method for finding zeros of real univariate differentiable
functions.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Set of

`BSP tree`

nodes.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Non-linear conjugate gradient optimizer.

Available choices of update formulas for the updating the parameter
that is used to compute the successive conjugate search directions.

Default identity preconditioner.

Container for

`non-linear process`

evolution data.Non-linear process that can be estimated by a

`ExtendedKalmanFilter`

.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

A constraint for a linear optimization problem indicating whether all
variables must be restricted to non-negative values.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Implementation of the normal (gaussian) distribution.

This interface represent a normalized random generator for
scalars.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

All conditions checks that fail due to a

`null`

argument must throw
this exception.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Scalar function to be optimized.

Gradient of the scalar function to be optimized.

This interface represents a detector for discrete events triggered
during ODE integration.

This interface represents a handler for discrete events triggered
during ODE integration.

This interface represents a handler that should be called after
each successful fixed step.

This interface represents a first order integrator for
differential equations.

Interface expanding

```
first order
differential equations
```

in order to compute exactly the Jacobian
matrices for `partial derivatives equations`

.Container for time, main and secondary state vectors.

Container for time, main and secondary state vectors as well as their derivatives.

This interface represents an interpolator over the last step
during an ODE integration.

This interface represents a handler that should be called after
each successful step.

Implements ordinary least squares (OLS) to estimate the parameters of a
multiple linear regression model.

Implements one-way ANOVA (analysis of variance) statistics.

Open addressed map from int to double.

Open addressed map from int to FieldElement.

Sparse matrix implementation based on an open addressed map.

This class implements the

`RealVector`

interface with a
`OpenIntToDoubleHashMap`

backing store.Marker interface.

Common settings for all optimization problems.

Given a matrix A, it computes a complex eigen decomposition A = VDV^{T}.

This interface represents a first order differential equations set.

This class represents a 1D oriented hyperplane.

Extractor for

`polyhedrons sets`

outlines.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Generic pair.

Simple container pairing a parameter name with a step in order to compute
the associated Jacobian matrix by finite difference.

This interface enables to process any parameterizable object.

Deprecated.

as of 1.0, replaced with

`NamedParameterJacobianProvider`

Interface to compute by finite difference Jacobian matrix for some parameter
when computing

`partial derivatives equations`

.Interface for validating a set of model parameters.

An interface representing a real function that depends on one independent
variable plus some extra parameters.

Implementation of the Pareto distribution.

Implementation of the Pascal distribution.

Principal component analysis (PCA) is a statistical technique for reducing the dimensionality of a dataset.

Computes Pearson's product-moment correlation coefficients for pairs of arrays
or columns of a matrix.

Implements the

*Pegasus*method for root-finding (approximating a zero of a univariate real function).Provides percentile computation.

An enum for various estimation strategies of a percentile referred in
wikipedia on quantile
with the names of enum matching those of types mentioned in
wikipedia.

Function that implements the
bicubic spline
interpolation.

Generates a piecewise-bicubic interpolating function.

A strategy to pick a pivoting index of an array for doing partitioning.

Pivot selection rule to the use for a Simplex solver.

The class represent planes in a three dimensional space.

This interface represents a generic geometrical point.

This class holds a point and the value of an objective function at
that point.

This class holds a point and the vectorial value of an objective function at
that point.

Implementation of the Poisson distribution.

This class represents a 2D region: a set of polygons.

This class represents a 3D region: a set of polyhedrons.

Container for Boundary REPresentation (B-Rep).

Fits points to a

`polynomial`

function.Immutable representation of a real polynomial function with real coefficients.

Dedicated parametric polynomial class.

Implements the representation of a real polynomial function in
Lagrange Form.

Implements the representation of a real polynomial function in
Newton Form.

Interface for (polynomial) root-finding algorithms.

Represents a polynomial spline function.

A collection of static methods that operate on or return polynomials.

Power function.

Powell's algorithm.

Power function.

Utilities for comparing numbers.

This abstract class defines preconditioned iterative solvers.

This interface represents a preconditioner for differentiable scalar
objective function optimizers.

Holder for process state and covariance.

Returns the product of the available values.

Formats a BigFraction number in proper format.

Formats a Fraction number in proper format.

A

`StorelessUnivariateStatistic`

estimating percentiles using the
P^{2}Algorithm as explained by Raj Jain and Imrich Chlamtac in P^{2}Algorithm for Dynamic Calculation of Quantiles and Histogram Without Storing Observations.An interface that encapsulates abstractions of the
P-square algorithm markers as is explained in the original works.

Quadratic programming Optimizater.

Matrix decomposer using QR-decomposition.

Calculates the QR-decomposition of a matrix.

Given P, Q, d, implements \(\frac{1}{2}x^T P X + Q^T x + d\).

This class implements
quaternions (Hamilton's hypercomplex numbers).

Extension of

`Random`

wrapping a
`RandomGenerator`

.A class for generating random data.

Interface for generators of random number sequences.

A

`StorelessUnivariateStatistic`

estimating percentiles using the
RANDOM
Algorithm.This interface represents a random generator for whole vectors.

Interface representing a rank transformation.

Base interface for continuous distributions.

Displays pdf/cdf for real distributions.

Main frame for displaying distributions.

This class defines a linear operator operating on real (

`double`

)
vector spaces.Interface defining a real-valued matrix with basic algebraic operations.

Interface defining a visitor for matrix entries.

Formats a

`nxm`

matrix in components list format
"{{a_{0}_{0},a_{0}_{1}, ..., a_{0}_{m-1}},{a_{1}_{0}, a_{1}_{1}, ..., a_{1}_{m-1}},{...},{ a_{n-1}_{0}, a_{n-1}_{1}, ..., a_{n-1}_{m-1}}}".Interface defining a visitor for matrix entries.

Interface for one-dimensional data sets transformations producing real results.

Class defining a real-valued vector with basic algebraic operations.

This interface defines a visitor for the entries of a vector.

Formats a vector in components list format "{v0; v1; ...; vk-1}".

This interface defines a visitor for the entries of a vector.

Calculates the rectangular Cholesky decomposition of a matrix.

This interface represents a region of a space as a partition.

Enumerate for the location of a point with respect to the region.

This class is a factory for

`Region`

.Results of a Multiple Linear Regression model fit.

Implements the

*Regula Falsi*or*False position*method for root-finding (approximating a zero of a univariate real function).Types of relationships between two cells in a Solver

`LinearConstraint`

.A variable length primitive double array implementation that automatically
handles expanding and contracting its internal storage array as elements
are added and removed.

Specification of expansion algorithm.

An algebraic Riccati equation is a type of nonlinear equation that arises in
the context of infinite-horizon optimal control problems in continuous time
or discrete time.

This solver computes the solution using the following approach:
1.

Implements the
Ridders' Method for root finding of real univariate functions.

`rint`

function.Implements the
Romberg Algorithm for integration of real univariate functions.

A helper class for the computation and caching of the

`n`

-th roots
of unity.An iterator that generates all partitions of

`n`

elements, into `k`

parts
containing the number of elements in each part, based on Rosen's algorithm.This class implements rotations in a three-dimensional space.

This enumerates is used to differentiate the semantics of a rotation.

Enumerate representing a rotation order specification for Cardan or Euler angles.

Calculates the rank-revealing QR-decomposition of a matrix, with column pivoting.

Interface for rules that determines the integration nodes and their weights.

This class implements the common part of all fixed step Runge-Kutta
integrators for Ordinary Differential Equations.

An implementation of RyÅ« for double.

This class represents a point on the 1-sphere.

This class represents a point on the 2-sphere.

Domain coloring enhancing modules changes.

Domain coloring enhancing both phase and module changes.

Class transforming a general real matrix to Schur form.

Search interval and (optional) start value.

Implements the

*Secant*method for root-finding (approximating a zero of a univariate real function).Deprecated.

as of 1.0, replaced with

`SecondaryODE`

Computes a statistic related to the Second Central Moment.

Deprecated.

as of 1.0, replaced with

`SecondOrderODE`

This interface represents a second order differential equations set.

Simple container for a two-points segment.

Simple container for a two-points segment.

Calculates the Cholesky decomposition of a positive semidefinite matrix.

Computes the semivariance of a set of values with respect to a given cutoff value.

The direction of the semivariance - either upside or downside.

Sequential Gauss-Newton least-squares solver.

Enumerate representing the location of an element with respect to an

`hyperplane`

of a space.
Sigmoid function.

Parametric function where the input array contains the parameters of
the

`sigmoid function`

, ordered
as follows:
Lower asymptote
Higher asymptote
Simple optimization constraints: lower and upper bounds.

Fits points to a user-defined

`function`

.Simple implementation of the

`ConvergenceChecker`

interface using
only point coordinates.Estimates an ordinary least squares regression model
with one independent variable.

Simple implementation of the

`ConvergenceChecker`

interface
that uses only objective function values.Simple implementation of the

`ConvergenceChecker`

interface using
only objective function values.Simple implementation of the

`ConvergenceChecker`

interface using
only objective function values.This class implements simplex-based direct search optimization.

Solves a linear problem using the "Two-Phase Simplex" method.

Implements
Simpson's Rule for integration of real univariate functions.

Sine function.

Sinc function,
defined by

Holder for both sine and cosine values.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Matrix decomposer using Singular Value Decomposition.

Calculates the compact Singular Value Decomposition of a matrix.

Hyperbolic sine function.

Holder for both hyperbolic sine and hyperbolic cosine values.

Computes the skewness of the available values.

Smoothstep function factory.

Smoothstep function as defined here.

Specific smoothstep function that cannot be built using the

`SmoothStepFactory.getGeneralOrder(int)`

.Smoothstep function as defined here.

Implementation of a Sobol sequence.

A callback object that can be provided to a linear optimizer to keep track
of the best solution found.

This interface represents a generic space, with affine and vectorial counterparts.

Sparse matrix implementation based on an open addressed map.

This class implements the

`FieldVector`

interface with a `OpenIntToFieldHashMap`

backing store.First derivative computation with large number of variables.

Marker interface for

`RealMatrix`

implementations that require sparse backing storageMarker class for RealVectors that require sparse backing storage

Spearman's rank correlation.

This class implements a one-dimensional sphere (i.e.

Specialized exception for inexistent sub-space.

This class implements a two-dimensional sphere (i.e.

Class generating an enclosing ball from its support points.

This class provides conversions related to spherical coordinates.

This class represents a region on the 2-sphere: a set of spherical polygons.

Computes a natural (also known as "free", "unclamped") cubic spline interpolation for the data set.

Sequential Quadratic Programming Optimizer.

Sequential Quadratic Programming Optimizer.

Parameter for SQP Algorithm.

Square-root function.

This class provides a stable normalized random generator.

Computes the sample standard deviation.

Reporting interface for basic multivariate statistics.

Reporting interface for basic univariate statistics.

Value object representing the results of a univariate
statistical summary.

StatUtils provides static methods for computing statistics based on data
stored in double[] arrays.

This class handles the state for one

`event handler`

that triggers at step end.Deprecated.

as of 1.0, replaced with

`ODEStepHandler`

Deprecated.

as of 1.0, replaced with

`ODEStateInterpolator`

This class wraps an object implementing

`ODEFixedStepHandler`

into a `ODEStepHandler`

.`Step normalizer`

bounds settings.`Step normalizer`

modes.Helper for adaptive stepsize control.

Covariance implementation that does not require input data to be
stored in memory.

Base interface implemented by storeless multivariate statistics.

Extends the definition of

`UnivariateStatistic`

with
`StorelessUnivariateStatistic.increment(double)`

and `StorelessUnivariateStatistic.incrementAll(double[])`

methods for adding
values and updating internal state.Computes summary statistics for a stream of data values added using the

`addValue`

method.Builder for StreamingStatistics instances.

This class represents a sub-hyperplane for

`Circle`

.This interface represents the remaining parts of an hyperplane after
other parts have been chopped off.

Class holding the results of the

`split`

method.This class represents sub-hyperplane for

`LimitAngle`

.This class represents a subset of a

`Line`

.This class represents a sub-hyperplane for

`Line`

.This class represents sub-hyperplane for

`OrientedPoint`

.This class represents a sub-hyperplane for

`Plane`

.Subtract the second operand from the first.

Returns the sum of the available values.

Computes the sum of intra-cluster distance variances according to the formula:
\] score = \sum\limits_{i=1}^n \sigma_i^2 \]
where n is the number of clusters and \( \sigma_i^2 \) is the variance of
intra-cluster distances of cluster \( c_i \).

Returns the sum of the natural logs for this collection of values.

Returns the sum of the squares of the available values.

Interface for generating balls based on support points.

This class's implements

`integrate`

method assuming that the integral is symmetric about 0.This class's implements

`integrate`

method assuming that the integral is symmetric about 0.
Implementation of the SYMMLQ iterative linear solver proposed by Paige and Saunders (1975).

Any

`RandomGenerator`

implementation can be thread-safe if it
is used through an instance of this class.Tangent function.

Hyperbolic tangent function.

Container for a Taylor map.

Implementation of Student's t-distribution.

Values of

`Jacobi theta`

functions.This class implements the 3/8 fourth order Runge-Kutta
integrator for Ordinary Differential Equations.

Strategies for handling tied values in rank transformations.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

This interface represents an inversible affine transform in a space.

This enumeration defines the type of transform which is to be computed.

Useful functions for the implementation of various transforms.

Implements the
Trapezoid Rule for integration of real univariate functions.

Implementation of the triangular real distribution.

Function that implements the
tricubic spline interpolation, as proposed in
Tricubic interpolation in three dimensions

F.

F.

Generates a tricubic interpolating function.

An interface representing a trivariate real function.

Interface representing a trivariate real interpolating function where the
sample points must be specified on a regular grid.

An implementation for Student's t-tests.

This class allows to perform the same computation of all components of a Tuple at once.

A MultivariateFunction that also has a defined gradient and Hessian.

`ulp`

function.Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalStateException`

A

`RandomVectorGenerator`

that generates vectors with uncorrelated components.Implementation of the uniform integer distribution.

This class implements a normalized uniform random generator.

Implementation of the uniform real distribution.

Generate random vectors isotropically located on the surface of a sphere.

Abstract class representing both the value and the differentials of a function.

Class representing both the value and the differentials of a function.

Field for

`UnivariateDerivative1`

instances.Class representing both the value and the differentials of a function.

Field for

`UnivariateDerivative2`

instances.Interface for univariate functions derivatives.

Extension of

`UnivariateMatrixFunction`

representing a univariate differentiable matrix function.Interface for (univariate real) rootfinding algorithms.

Extension of

`UnivariateVectorFunction`

representing a univariate differentiable vectorial function.An interface representing a univariate real function.

Interface defining the function differentiation operation.

Interface for univariate real integration algorithms.

Interface representing a univariate real interpolating function.

An interface representing a univariate matrix function.

Interface defining the function differentiation operation.

Scalar function to be optimized.

Base class for a univariate scalar function optimizer.

Adapter for classes implementing the

`UnivariateInterpolator`

interface.This class holds a point and the value of an objective function at this
point.

Interface for (univariate real) root-finding algorithms.

Utility routines for

`UnivariateSolver`

objects.Base interface implemented by all statistics.

An interface representing a univariate vectorial function.

Interface defining the function differentiation operation.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Container for

`unscented process`

evolution data.Unscented Kalman filter for

`unscented process`

.Unscented process that can be estimated by a

`UnscentedKalmanFilter`

.Provider for unscented transform.

An interface for regression models allowing for dynamic updating of the data.

Control class loading properties in UTF-8 encoding.

Computes the variance of the available values.

This class defines a set of

`secondary equations`

to
compute the global Jacobian matrices with respect to the initial state
vector and, if any, to some parameters of the primary ODE set.Special exception for equations mismatch.

This interface represents a generic vector in a vectorial space or a point in an affine space.

This class represents a 1D vector.

Formats a 1D vector in components list format "{x}".

This class represents a 2D vector.

Formats a 2D vector in components list format "{x; y}".

This class implements vectors in a three-dimensional space.

Formats a 3D vector in components list format "{x; y; z}".

A MultivariateFunction that also has a defined gradient and Hessian.

Formats a vector in components list format "{x; y; ...}".

Returns the covariance matrix of the available vectors.

Uses an independent

`StorelessUnivariateStatistic`

instance
for each component of a vector.Spherical polygons boundary vertex.

Implementation of the Weibull distribution.

Weighted evaluation for statistics.

This class is a simple container for weighted observed point in

`curve fitting`

.Simple container for weighted observed points used
in

`curve fitting`

algorithms.This class implements the WELL1024a pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

This class implements the WELL19937a pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

This class implements the WELL19937c pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

This class implements the WELL44497a pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

This class implements the WELL44497b pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

This class implements the WELL512a pseudo-random number generator
from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto.

Class implementing Emo Welzl algorithm to find the smallest enclosing ball in linear time.

An implementation of the Wilcoxon signed-rank test.

Deprecated.

as of 1.0, this exception is replaced by

`MathIllegalArgumentException`

Implementation of the Zipf distribution.

`MathIllegalStateException`