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(pi;x), where x is the independent variable and the pi 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.
AbstractRegion<S extends Space,T extends Space>
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.
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.
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.
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.
BSPTree<S extends Space>
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.
as of 1.0, this exception is replaced by MathIllegalStateException
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).
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".
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
Factory converting field-based FieldRuleFactory into RuleFactory.
ConvexHull<S extends Space,P extends Point<S>>
This class represents a convex hull.
This class represents a convex hull in an two-dimensional euclidean space.
ConvexHullGenerator<S extends Space,P extends Point<S>>
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.
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 class implements the common part of all embedded Runge-Kutta integrators for Ordinary Differential Equations.
Embedding<S extends Space,T extends Space>
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.
Encloser<S extends Space,P extends Point<S>>
Interface for algorithms computing enclosing balls.
EnclosingBall<S extends Space,P extends Point<S>>
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 L2 (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.
ex-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.
Field for {link FieldDerivativeStructure} instances.
Field<T extends FieldElement<T>>
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.
Interface representing classes that can blend with other instances of themselves using a given blending value.
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.
This class stores all information provided by an ODE integrator during the integration process and build a continuous model of the solution from this.
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.
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.
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 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.
This interface allows users to add secondary differential equations to a primary set of differential equations.
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.
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.
Class that provides different ways to compute the nodes and weights to be used by the 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 .
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.
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.
Hyperplane<S extends Space>
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 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 Kth selector implementation to pick up the Kth 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 LeastSquaresProblems.
This class converts vectorial objective functions to scalar objective functions when the goal is to minimize them.
A Factory for creating LeastSquaresProblems.
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.
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.
This class implements the Luther sixth order Runge-Kutta integrator for Ordinary Differential Equations.
Deprecated.
as of 1.0, replaced with ODEJacobiansProvider
Calculates the L1 (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
NodesSet<S extends Space>
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 for discrete events triggered during ODE integration at each step end.
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.
Point<S extends 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 P2 Algorithm as explained by Raj Jain and Imrich Chlamtac in P2 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 "{{a00,a01, ..., a0m-1},{a10, a11, ..., a1m-1},{...},{ an-10, an-11, ..., an-1m-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.
Region<S extends Space>
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.
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
This interface allows users to add secondary differential equations to a primary set of differential equations.
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.
SimplePointChecker<P extends Pair<double[],? extends Object>>
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 storage
Marker 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.
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.
SupportBallGenerator<S extends Space,P extends Point<S>>
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.
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
Transform<S extends Space,T extends Space>
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.
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.
A interface for functions that compute a vector of values and can compute their derivatives (Jacobian).
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.
Vector<S extends Space,V extends Vector<S,V>>
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.
VectorFormat<S extends Space,V extends Vector<S,V>>
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.
WelzlEncloser<S extends Space,P extends Point<S>>
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.