Uses of Class org.hipparchus.exception.MathIllegalArgumentException (Hipparchus 1.4 API)

Packages that use MathIllegalArgumentException
Package	Description
org.hipparchus	Common classes used throughout the Hipparchus library.
org.hipparchus.analysis	Parent package for common numerical analysis procedures, including root finding, function interpolation and integration.
org.hipparchus.analysis.differentiation	This package holds the main interfaces and basic building block classes dealing with differentiation.
org.hipparchus.analysis.function	The `function` package contains function objects that wrap the methods contained in `Math`, as well as common mathematical functions such as the gaussian and sinc functions.
org.hipparchus.analysis.integration	Numerical integration (quadrature) algorithms for univariate real functions.
org.hipparchus.analysis.integration.gauss	Gauss family of quadrature schemes.
org.hipparchus.analysis.interpolation	Univariate real functions interpolation algorithms.
org.hipparchus.analysis.polynomials	Univariate real polynomials implementations, seen as differentiable univariate real functions.
org.hipparchus.analysis.solvers	Root finding algorithms, for univariate real functions.
org.hipparchus.clustering	Clustering algorithms.
org.hipparchus.clustering.distance	Common distance measures.
org.hipparchus.complex	Complex number type and implementations of complex transcendental functions.
org.hipparchus.dfp	Decimal floating point library for Java
org.hipparchus.distribution	Interfaces and implementations of common discrete and continuous distributions.
org.hipparchus.distribution.continuous	Implementations of common continuous distributions.
org.hipparchus.distribution.discrete	Implementations of common discrete distributions.
org.hipparchus.distribution.multivariate	Implementations of multivariate distributions.
org.hipparchus.filtering.kalman	Kalman filter.
org.hipparchus.fraction	Fraction number type and fraction number formatting.
org.hipparchus.geometry.euclidean.threed	This package provides basic 3D geometry components.
org.hipparchus.geometry.euclidean.twod	This package provides basic 2D geometry components.
org.hipparchus.geometry.euclidean.twod.hull	This package provides algorithms to generate the convex hull for a set of points in an two-dimensional euclidean space.
org.hipparchus.geometry.hull	This package provides interfaces and classes related to the convex hull problem.
org.hipparchus.geometry.spherical.oned	This package provides basic geometry components on the 1-sphere.
org.hipparchus.geometry.spherical.twod	This package provides basic geometry components on the 2-sphere.
org.hipparchus.linear	Linear algebra support.
org.hipparchus.migration.exception	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.migration.genetics	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.migration.geometry.euclidean.threed	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.migration.linear	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.migration.ode	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.migration.stat.regression	This package provides migration classes from Apache Commons Math to Hipparchus.
org.hipparchus.ode	This package provides classes to solve Ordinary Differential Equations problems.
org.hipparchus.ode.events	Events
org.hipparchus.ode.nonstiff	This package provides classes to solve non-stiff Ordinary Differential Equations problems.
org.hipparchus.optim.nonlinear.scalar	Algorithms for optimizing a scalar function.
org.hipparchus.optim.nonlinear.scalar.noderiv	This package provides optimization algorithms that do not require derivatives.
org.hipparchus.random	Random number and random data generators.
org.hipparchus.special	Implementations of special functions such as Beta and Gamma.
org.hipparchus.stat	Data storage, manipulation and summary routines.
org.hipparchus.stat.correlation	Correlations/Covariance computations.
org.hipparchus.stat.descriptive	Generic univariate and multivariate summary statistic objects.
org.hipparchus.stat.descriptive.moment	Summary statistics based on moments.
org.hipparchus.stat.descriptive.rank	Summary statistics based on ranks.
org.hipparchus.stat.descriptive.summary	Other summary statistics.
org.hipparchus.stat.descriptive.vector	Multivariate statistics.
org.hipparchus.stat.fitting	Statistical methods for fitting distributions.
org.hipparchus.stat.inference	Classes providing hypothesis testing.
org.hipparchus.stat.interval	Utilities to calculate binomial proportion confidence intervals.
org.hipparchus.stat.regression	Statistical routines involving multivariate data.
org.hipparchus.transform	Implementations of transform methods, including Fast Fourier transforms.
org.hipparchus.util	Convenience routines and common data structures used throughout the Hipparchus library.

Uses of MathIllegalArgumentException in org.hipparchus

Methods in org.hipparchus that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`T`	RealFieldElement.`atan2(T x)`	Two arguments arc tangent operation.
`T`	RealFieldElement.`hypot(T y)`	Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`T`	RealFieldElement.`linearCombination(double[] a, T[] b)`	Compute a linear combination.
`T`	RealFieldElement.`linearCombination(T[] a, T[] b)`	Compute a linear combination.
`T`	RealFieldElement.`pow(T e)`	Power operation.
`T`	RealFieldElement.`remainder(T a)`	IEEE remainder operator.

Uses of MathIllegalArgumentException in org.hipparchus.analysis

Methods in org.hipparchus.analysis that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static double[]`	FunctionUtils.`sample(UnivariateFunction f, double min, double max, int n)`	Samples the specified univariate real function on the specified interval.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.differentiation

Methods in org.hipparchus.analysis.differentiation that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`DerivativeStructure`	DerivativeStructure.`add(DerivativeStructure a)`	Compute this + a.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`add(FieldDerivativeStructure<T> a)`	Compute this + a.
`DerivativeStructure`	DerivativeStructure.`atan2(DerivativeStructure x)`	Two arguments arc tangent operation.
`static DerivativeStructure`	DerivativeStructure.`atan2(DerivativeStructure y, DerivativeStructure x)`	Two arguments arc tangent operation.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`atan2(FieldDerivativeStructure<T> x)`	Two arguments arc tangent operation.
`static <T extends RealFieldElement<T>> FieldDerivativeStructure<T>`	FieldDerivativeStructure.`atan2(FieldDerivativeStructure<T> y, FieldDerivativeStructure<T> x)`	Two arguments arc tangent operation.
`DerivativeStructure`	DSFactory.`build(double... derivatives)`	Build a `DerivativeStructure` from all its derivatives.
`FieldDerivativeStructure<T>`	FDSFactory.`build(double... derivatives)`	Build a `FieldDerivativeStructure` from all its derivatives.
`FieldDerivativeStructure<T>`	FDSFactory.`build(T... derivatives)`	Build a `FieldDerivativeStructure` from all its derivatives.
`void`	DSCompiler.`checkCompatibility(DSCompiler compiler)`	Check rules set compatibility.
`DerivativeStructure`	DerivativeStructure.`compose(double... f)`	Compute composition of the instance by a univariate function.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`compose(double... f)`	Compute composition of the instance by a univariate function.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`compose(T... f)`	Compute composition of the instance by a univariate function.
`DerivativeStructure`	DerivativeStructure.`divide(DerivativeStructure a)`	Compute this ÷ a.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`divide(FieldDerivativeStructure<T> a)`	Compute this ÷ a.
`static DSCompiler`	DSCompiler.`getCompiler(int parameters, int order)`	Get the compiler for number of free parameters and order.
`double`	DerivativeStructure.`getPartialDerivative(int... orders)`	Get a partial derivative.
`T`	FieldDerivativeStructure.`getPartialDerivative(int... orders)`	Get a partial derivative.
`int`	DSCompiler.`getPartialDerivativeIndex(int... orders)`	Get the index of a partial derivative in the array.
`DerivativeStructure`	DerivativeStructure.`hypot(DerivativeStructure y)`	Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`static DerivativeStructure`	DerivativeStructure.`hypot(DerivativeStructure x, DerivativeStructure y)`	Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x² +y²) avoiding intermediate overflow or underflow.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`hypot(FieldDerivativeStructure<T> y)`	Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`static <T extends RealFieldElement<T>> FieldDerivativeStructure<T>`	FieldDerivativeStructure.`hypot(FieldDerivativeStructure<T> x, FieldDerivativeStructure<T> y)`	Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x² +y²) avoiding intermediate overflow or underflow.
`DerivativeStructure`	DerivativeStructure.`linearCombination(double[] a, DerivativeStructure[] b)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2, double a3, DerivativeStructure b3)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2, double a3, DerivativeStructure b3, double a4, DerivativeStructure b4)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(DerivativeStructure[] a, DerivativeStructure[] b)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2, DerivativeStructure a3, DerivativeStructure b3)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2, DerivativeStructure a3, DerivativeStructure b3, DerivativeStructure a4, DerivativeStructure b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(double[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2, double a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2, double a3, FieldDerivativeStructure<T> b3, double a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(FieldDerivativeStructure<T>[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2, FieldDerivativeStructure<T> a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2, FieldDerivativeStructure<T> a3, FieldDerivativeStructure<T> b3, FieldDerivativeStructure<T> a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(T[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2, T a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2, T a3, FieldDerivativeStructure<T> b3, T a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`SparseGradient`	SparseGradient.`linearCombination(SparseGradient[] a, SparseGradient[] b)`	Compute a linear combination.
`DerivativeStructure`	DerivativeStructure.`multiply(DerivativeStructure a)`	Compute this × a.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`multiply(FieldDerivativeStructure<T> a)`	Compute this × a.
`DerivativeStructure`	DerivativeStructure.`pow(DerivativeStructure e)`	Power operation.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`pow(FieldDerivativeStructure<T> e)`	Power operation.
`DerivativeStructure`	DerivativeStructure.`remainder(DerivativeStructure a)`	IEEE remainder operator.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`remainder(FieldDerivativeStructure<T> a)`	IEEE remainder operator.
`DerivativeStructure`	DerivativeStructure.`subtract(DerivativeStructure a)`	Compute this - a.
`FieldDerivativeStructure<T>`	FieldDerivativeStructure.`subtract(FieldDerivativeStructure<T> a)`	Compute this - a.
`DerivativeStructure`	MultivariateDifferentiableFunction.`value(DerivativeStructure[] point)`	Compute the value for the function at the given point.
`DerivativeStructure[]`	MultivariateDifferentiableVectorFunction.`value(DerivativeStructure[] point)`	Compute the value for the function at the given point.
`DerivativeStructure`	UnivariateDifferentiableFunction.`value(DerivativeStructure t)`	Simple mathematical function.
`DerivativeStructure[][]`	UnivariateDifferentiableMatrixFunction.`value(DerivativeStructure x)`	Compute the value for the function.
`DerivativeStructure[]`	UnivariateDifferentiableVectorFunction.`value(DerivativeStructure x)`	Compute the value for the function.
`DerivativeStructure`	DSFactory.`variable(int index, double value)`	Build a `DerivativeStructure` representing a variable.
`FieldDerivativeStructure<T>`	FDSFactory.`variable(int index, double value)`	Build a `FieldDerivativeStructure` representing a variable.
`FieldDerivativeStructure<T>`	FDSFactory.`variable(int index, T value)`	Build a `FieldDerivativeStructure` representing a variable.

Constructors in org.hipparchus.analysis.differentiation that throw MathIllegalArgumentException
Constructor	Description
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2)`	Deprecated. as of 1.1, replaced by `DerivativeStructure.linearCombination(double, DerivativeStructure, double, DerivativeStructure)`
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3)`	Deprecated. as of 1.1, replaced by `DerivativeStructure.linearCombination(double, DerivativeStructure, double, DerivativeStructure, double, DerivativeStructure)`
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3, double a4, DerivativeStructure ds4)`	Deprecated. as of 1.1, replaced by `DerivativeStructure.linearCombination(double, DerivativeStructure, double, DerivativeStructure, double, DerivativeStructure, double, DerivativeStructure)`
`DerivativeStructure(int parameters, int order)`	Deprecated. as of 1.1, replaced by `DSFactory.build()`
`DerivativeStructure(int parameters, int order, double value)`	Deprecated. as of 1.1, replaced by `DSFactory.constant(double)`
`DerivativeStructure(int parameters, int order, double... derivatives)`	Deprecated. as of 1.1, replaced by `DSFactory.build(double...)`
`DerivativeStructure(int parameters, int order, int index, double value)`	Deprecated. as of 1.1, replaced by `DSFactory.variable(int, double)`
`FiniteDifferencesDifferentiator(int nbPoints, double stepSize)`	Build a differentiator with number of points and step size when independent variable is unbounded.
`FiniteDifferencesDifferentiator(int nbPoints, double stepSize, double tLower, double tUpper)`	Build a differentiator with number of points and step size when independent variable is bounded.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.function

Methods in org.hipparchus.analysis.function that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double[]`	Gaussian.Parametric.`gradient(double x, double... param)`	Computes the value of the gradient at `x`.
`double[]`	HarmonicOscillator.Parametric.`gradient(double x, double... param)`	Computes the value of the gradient at `x`.
`double[]`	Logistic.Parametric.`gradient(double x, double... param)`	Computes the value of the gradient at `x`.
`double[]`	Logit.Parametric.`gradient(double x, double... param)`	Computes the value of the gradient at `x`.
`double[]`	Sigmoid.Parametric.`gradient(double x, double... param)`	Computes the value of the gradient at `x`.
`double`	Gaussian.Parametric.`value(double x, double... param)`	Computes the value of the Gaussian at `x`.
`DerivativeStructure`	Gaussian.`value(DerivativeStructure t)`	Simple mathematical function.
`double`	HarmonicOscillator.Parametric.`value(double x, double... param)`	Computes the value of the harmonic oscillator at `x`.
`DerivativeStructure`	HarmonicOscillator.`value(DerivativeStructure t)`	Simple mathematical function.
`double`	Logistic.Parametric.`value(double x, double... param)`	Computes the value of the sigmoid at `x`.
`double`	Logit.Parametric.`value(double x, double... param)`	Computes the value of the logit at `x`.
`double`	Logit.`value(double x)`	Compute the value of the function.
`DerivativeStructure`	Logit.`value(DerivativeStructure t)`	Simple mathematical function.
`double`	Sigmoid.Parametric.`value(double x, double... param)`	Computes the value of the sigmoid at `x`.
`DerivativeStructure`	Sigmoid.`value(DerivativeStructure t)`	Simple mathematical function.
`DerivativeStructure`	Sinc.`value(DerivativeStructure t)`	Simple mathematical function.

Constructors in org.hipparchus.analysis.function that throw MathIllegalArgumentException
Constructor	Description
`Gaussian(double mean, double sigma)`	Normalized gaussian with given mean and standard deviation.
`Gaussian(double norm, double mean, double sigma)`	Gaussian with given normalization factor, mean and standard deviation.
`Logistic(double k, double m, double b, double q, double a, double n)`
`StepFunction(double[] x, double[] y)`	Builds a step function from a list of arguments and the corresponding values.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.integration

Methods in org.hipparchus.analysis.integration that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected double`	IterativeLegendreGaussIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`protected double`	MidPointIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`protected double`	TrapezoidIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`double`	BaseAbstractUnivariateIntegrator.`integrate(int maxEval, UnivariateFunction f, double lower, double upper)`	Integrate the function in the given interval.
`double`	UnivariateIntegrator.`integrate(int maxEval, UnivariateFunction f, double min, double max)`	Integrate the function in the given interval.
`protected void`	BaseAbstractUnivariateIntegrator.`setup(int maxEval, UnivariateFunction f, double lower, double upper)`	Prepare for computation.

Constructors in org.hipparchus.analysis.integration that throw MathIllegalArgumentException
Constructor	Description
`BaseAbstractUnivariateIntegrator(double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Construct an integrator with given accuracies and iteration counts.
`BaseAbstractUnivariateIntegrator(int minimalIterationCount, int maximalIterationCount)`	Construct an integrator with given iteration counts.
`IterativeLegendreGaussIntegrator(int n, double relativeAccuracy, double absoluteAccuracy)`	Builds an integrator with given accuracies.
`IterativeLegendreGaussIntegrator(int n, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Builds an integrator with given accuracies and iterations counts.
`IterativeLegendreGaussIntegrator(int n, int minimalIterationCount, int maximalIterationCount)`	Builds an integrator with given iteration counts.
`MidPointIntegrator(double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a midpoint integrator with given accuracies and iterations counts.
`MidPointIntegrator(int minimalIterationCount, int maximalIterationCount)`	Build a midpoint integrator with given iteration counts.
`RombergIntegrator(double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a Romberg integrator with given accuracies and iterations counts.
`RombergIntegrator(int minimalIterationCount, int maximalIterationCount)`	Build a Romberg integrator with given iteration counts.
`SimpsonIntegrator(double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a Simpson integrator with given accuracies and iterations counts.
`SimpsonIntegrator(int minimalIterationCount, int maximalIterationCount)`	Build a Simpson integrator with given iteration counts.
`TrapezoidIntegrator(double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a trapezoid integrator with given accuracies and iterations counts.
`TrapezoidIntegrator(int minimalIterationCount, int maximalIterationCount)`	Build a trapezoid integrator with given iteration counts.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.integration.gauss

Methods in org.hipparchus.analysis.integration.gauss that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected void`	BaseRuleFactory.`addRule(Pair<T[],T[]> rule)`	Stores a rule.
`protected abstract Pair<T[],T[]>`	BaseRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected Pair<Double[],Double[]>`	HermiteRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected Pair<BigDecimal[],BigDecimal[]>`	LegendreHighPrecisionRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected Pair<Double[],Double[]>`	LegendreRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`Pair<double[],double[]>`	BaseRuleFactory.`getRule(int numberOfPoints)`	Gets a copy of the quadrature rule with the given number of integration points.
`protected Pair<T[],T[]>`	BaseRuleFactory.`getRuleInternal(int numberOfPoints)`	Gets a rule.
`GaussIntegrator`	GaussIntegratorFactory.`legendre(int numberOfPoints, double lowerBound, double upperBound)`	Creates a Gauss-Legendre integrator of the given order.
`GaussIntegrator`	GaussIntegratorFactory.`legendreHighPrecision(int numberOfPoints)`	Creates a Gauss-Legendre integrator of the given order.
`GaussIntegrator`	GaussIntegratorFactory.`legendreHighPrecision(int numberOfPoints, double lowerBound, double upperBound)`	Creates an integrator of the given order, and whose call to the `integrate` method will perform an integration on the given interval.

Constructors in org.hipparchus.analysis.integration.gauss that throw MathIllegalArgumentException
Constructor	Description
`GaussIntegrator(double[] points, double[] weights)`	Creates an integrator from the given `points` and `weights`.
`GaussIntegrator(Pair<double[],double[]> pointsAndWeights)`	Creates an integrator from the given pair of points (first element of the pair) and weights (second element of the pair.
`SymmetricGaussIntegrator(double[] points, double[] weights)`	Creates an integrator from the given `points` and `weights`.
`SymmetricGaussIntegrator(Pair<double[],double[]> pointsAndWeights)`	Creates an integrator from the given pair of points (first element of the pair) and weights (second element of the pair.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.interpolation

Methods in org.hipparchus.analysis.interpolation that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	FieldHermiteInterpolator.`addSamplePoint(T x, T[]... value)`	Add a sample point.
`void`	HermiteInterpolator.`addSamplePoint(double x, double[]... value)`	Add a sample point.
`protected static double[]`	DividedDifferenceInterpolator.`computeDividedDifference(double[] x, double[] y)`	Return a copy of the divided difference array.
`T[][]`	FieldHermiteInterpolator.`derivatives(T x, int order)`	Interpolate value and first derivatives at a specified abscissa.
`double[][]`	HermiteInterpolator.`derivatives(double x, int order)`	Interpolate value and first derivatives at a specified abscissa.
`PolynomialFunction[]`	HermiteInterpolator.`getPolynomials()`	Compute the interpolation polynomials.
`PolynomialSplineFunction`	AkimaSplineInterpolator.`interpolate(double[] xvals, double[] yvals)`	Computes an interpolating function for the data set.
`BicubicInterpolatingFunction`	BicubicInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`	Compute an interpolating function for the dataset.
`BilinearInterpolatingFunction`	BilinearInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`	Compute an interpolating function for the dataset.
`BivariateFunction`	BivariateGridInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`	Compute an interpolating function for the dataset.
`PolynomialFunctionNewtonForm`	DividedDifferenceInterpolator.`interpolate(double[] x, double[] y)`	Compute an interpolating function for the dataset.
`PolynomialSplineFunction`	LinearInterpolator.`interpolate(double[] x, double[] y)`	Computes a linear interpolating function for the data set.
`PolynomialSplineFunction`	LoessInterpolator.`interpolate(double[] xval, double[] yval)`	Compute an interpolating function by performing a loess fit on the data at the original abscissae and then building a cubic spline with a `SplineInterpolator` on the resulting fit.
`MultivariateFunction`	MicrosphereProjectionInterpolator.`interpolate(double[][] xval, double[] yval)`	Computes an interpolating function for the data set.
`MultivariateFunction`	MultivariateInterpolator.`interpolate(double[][] xval, double[] yval)`	Computes an interpolating function for the data set.
`PolynomialFunctionLagrangeForm`	NevilleInterpolator.`interpolate(double[] x, double[] y)`	Computes an interpolating function for the data set.
`PiecewiseBicubicSplineInterpolatingFunction`	PiecewiseBicubicSplineInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`	Compute an interpolating function for the dataset.
`PolynomialSplineFunction`	SplineInterpolator.`interpolate(double[] x, double[] y)`	Computes an interpolating function for the data set.
`TricubicInterpolatingFunction`	TricubicInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)`	Compute an interpolating function for the dataset.
`TrivariateFunction`	TrivariateGridInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)`	Compute an interpolating function for the dataset.
`UnivariateFunction`	UnivariateInterpolator.`interpolate(double[] xval, double[] yval)`	Compute an interpolating function for the dataset.
`UnivariateFunction`	UnivariatePeriodicInterpolator.`interpolate(double[] xval, double[] yval)`	Compute an interpolating function for the dataset.
`double[]`	LoessInterpolator.`smooth(double[] xval, double[] yval)`	Compute a loess fit on the data at the original abscissae.
`double[]`	LoessInterpolator.`smooth(double[] xval, double[] yval, double[] weights)`	Compute a weighted loess fit on the data at the original abscissae.
`double`	BicubicInterpolatingFunction.`value(double x, double y)`	Compute the value for the function.
`T[]`	FieldHermiteInterpolator.`value(T x)`	Interpolate value at a specified abscissa.
`double[]`	HermiteInterpolator.`value(double x)`	Interpolate value at a specified abscissa.
`DerivativeStructure[]`	HermiteInterpolator.`value(DerivativeStructure x)`	Interpolate value at a specified abscissa.
`double`	PiecewiseBicubicSplineInterpolatingFunction.`value(double x, double y)`	Compute the value for the function.
`double`	TricubicInterpolatingFunction.`value(double x, double y, double z)`	Compute the value for the function.

Constructors in org.hipparchus.analysis.interpolation that throw MathIllegalArgumentException
Constructor	Description
`BicubicInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)`
`BilinearInterpolatingFunction(double[] xVal, double[] yVal, double[][] fVal)`	Simple constructor.
`GridAxis(double[] grid, int n)`	Simple constructor.
`LoessInterpolator(double bandwidth, int robustnessIters, double accuracy)`	Construct a new `LoessInterpolator` with given bandwidth, number of robustness iterations and accuracy.
`MicrosphereProjectionInterpolator(InterpolatingMicrosphere microsphere, double exponent, boolean sharedSphere, double noInterpolationTolerance)`	Create a microsphere interpolator.
`PiecewiseBicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f)`
`TricubicInterpolatingFunction(double[] x, double[] y, double[] z, double[][][] f, double[][][] dFdX, double[][][] dFdY, double[][][] dFdZ, double[][][] d2FdXdY, double[][][] d2FdXdZ, double[][][] d2FdYdZ, double[][][] d3FdXdYdZ)`

Uses of MathIllegalArgumentException in org.hipparchus.analysis.polynomials

Methods in org.hipparchus.analysis.polynomials that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected static double[]`	PolynomialFunction.`differentiate(double[] coefficients)`	Returns the coefficients of the derivative of the polynomial with the given coefficients.
`protected static double`	PolynomialFunction.`evaluate(double[] coefficients, double argument)`	Uses Horner's Method to evaluate the polynomial with the given coefficients at the argument.
`static double`	PolynomialFunctionLagrangeForm.`evaluate(double[] x, double[] y, double z)`	Evaluate the Lagrange polynomial using Neville's Algorithm.
`static double`	PolynomialFunctionNewtonForm.`evaluate(double[] a, double[] c, double z)`	Evaluate the Newton polynomial using nested multiplication.
`double`	PolynomialFunction.Parametric.`value(double x, double... parameters)`	Compute the value of the function.
`DerivativeStructure`	PolynomialFunction.`value(DerivativeStructure t)`	Simple mathematical function.
`<T extends RealFieldElement<T>> T`	PolynomialFunction.`value(T t)`	Compute the value of the function.
`protected static void`	PolynomialFunctionNewtonForm.`verifyInputArray(double[] a, double[] c)`	Verifies that the input arrays are valid.
`static boolean`	PolynomialFunctionLagrangeForm.`verifyInterpolationArray(double[] x, double[] y, boolean abort)`	Check that the interpolation arrays are valid.

Constructors in org.hipparchus.analysis.polynomials that throw MathIllegalArgumentException
Constructor	Description
`PolynomialFunction(double[] c)`	Construct a polynomial with the given coefficients.
`PolynomialFunctionLagrangeForm(double[] x, double[] y)`	Construct a Lagrange polynomial with the given abscissas and function values.
`PolynomialFunctionNewtonForm(double[] a, double[] c)`	Construct a Newton polynomial with the given a[] and c[].
`PolynomialSplineFunction(double[] knots, PolynomialFunction[] polynomials)`	Construct a polynomial spline function with the given segment delimiters and interpolating polynomials.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.solvers

Methods in org.hipparchus.analysis.solvers that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static <T extends RealFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(RealFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound)`	This method simply calls `bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)` with `q` and `r` set to 1.0 and `maximumIterations` set to `Integer.MAX_VALUE`.
`static <T extends RealFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(RealFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound, int maximumIterations)`	This method simply calls `bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)` with `q` and `r` set to 1.0.
`static <T extends RealFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(RealFieldUnivariateFunction<T> function, T initial, T lowerBound, T upperBound, T q, T r, int maximumIterations)`	This method attempts to find two values a and b satisfying `lowerBound <= a < initial < b <= upperBound` `f(a) * f(b) <= 0` If `f` is continuous on `[a,b]`, this means that `a` and `b` bracket a root of `f`.
`static double[]`	UnivariateSolverUtils.`bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound)`	This method simply calls `bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)` with `q` and `r` set to 1.0 and `maximumIterations` set to `Integer.MAX_VALUE`.
`static double[]`	UnivariateSolverUtils.`bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound, double q, double r, int maximumIterations)`	This method attempts to find two values a and b satisfying `lowerBound <= a < initial < b <= upperBound` `f(a) * f(b) <= 0` If `f` is continuous on `[a,b]`, this means that `a` and `b` bracket a root of `f`.
`static double[]`	UnivariateSolverUtils.`bracket(UnivariateFunction function, double initial, double lowerBound, double upperBound, int maximumIterations)`	This method simply calls `bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)` with `q` and `r` set to 1.0.
`protected abstract double`	BaseAbstractUnivariateSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`protected double`	BrentSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`double`	LaguerreSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`protected double`	MullerSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`protected double`	MullerSolver2.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`protected double`	RiddersSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`protected double`	SecantSolver.`doSolve()`	Method for implementing actual optimization algorithms in derived classes.
`static double`	UnivariateSolverUtils.`forceSide(int maxEval, UnivariateFunction f, BracketedUnivariateSolver<UnivariateFunction> bracketing, double baseRoot, double min, double max, AllowedSolution allowedSolution)`	Force a root found by a non-bracketing solver to lie on a specified side, as if the solver were a bracketing one.
`double`	BaseAbstractUnivariateSolver.`solve(int maxEval, F f, double startValue)`	Solve for a zero in the vicinity of `startValue`.
`double`	BaseAbstractUnivariateSolver.`solve(int maxEval, F f, double min, double max, double startValue)`	Solve for a zero in the given interval, start at `startValue`.
`double`	BaseUnivariateSolver.`solve(int maxEval, F f, double min, double max)`	Solve for a zero root in the given interval.
`double`	BaseUnivariateSolver.`solve(int maxEval, F f, double min, double max, double startValue)`	Solve for a zero in the given interval, start at `startValue`.
`double`	BracketingNthOrderBrentSolver.`solve(int maxEval, UnivariateFunction f, double min, double max, double startValue, AllowedSolution allowedSolution)`	Solve for a zero in the given interval, start at `startValue`.
`double`	BracketingNthOrderBrentSolver.`solve(int maxEval, UnivariateFunction f, double min, double max, AllowedSolution allowedSolution)`	Solve for a zero in the given interval.
`T`	FieldBracketingNthOrderBrentSolver.`solve(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, AllowedSolution allowedSolution)`	Solve for a zero in the given interval.
`T`	FieldBracketingNthOrderBrentSolver.`solve(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, T startValue, AllowedSolution allowedSolution)`	Solve for a zero in the given interval, start at `startValue`.
`static double`	UnivariateSolverUtils.`solve(UnivariateFunction function, double x0, double x1)`	Convenience method to find a zero of a univariate real function.
`static double`	UnivariateSolverUtils.`solve(UnivariateFunction function, double x0, double x1, double absoluteAccuracy)`	Convenience method to find a zero of a univariate real function.
`Complex[]`	LaguerreSolver.`solveAllComplex(double[] coefficients, double initial)`	Find all complex roots for the polynomial with the given coefficients, starting from the given initial value.
`Complex`	LaguerreSolver.`solveComplex(double[] coefficients, double initial)`	Find a complex root for the polynomial with the given coefficients, starting from the given initial value.
`BracketedUnivariateSolver.Interval`	BaseSecantSolver.`solveInterval(int maxEval, UnivariateFunction f, double min, double max, double startValue)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`default BracketedRealFieldUnivariateSolver.Interval<T>`	BracketedRealFieldUnivariateSolver.`solveInterval(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`BracketedRealFieldUnivariateSolver.Interval<T>`	BracketedRealFieldUnivariateSolver.`solveInterval(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, T startValue)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`default BracketedUnivariateSolver.Interval`	BracketedUnivariateSolver.`solveInterval(int maxEval, F f, double min, double max)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`BracketedUnivariateSolver.Interval`	BracketedUnivariateSolver.`solveInterval(int maxEval, F f, double min, double max, double startValue)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`BracketedUnivariateSolver.Interval`	BracketingNthOrderBrentSolver.`solveInterval(int maxEval, UnivariateFunction f, double min, double max, double startValue)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`BracketedRealFieldUnivariateSolver.Interval<T>`	FieldBracketingNthOrderBrentSolver.`solveInterval(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, T startValue)`	Solve for a zero in the given interval and return a tolerance interval surrounding the root.
`protected void`	BaseAbstractUnivariateSolver.`verifyBracketing(double lower, double upper)`	Check that the endpoints specify an interval and the function takes opposite signs at the endpoints.
`static void`	UnivariateSolverUtils.`verifyBracketing(UnivariateFunction function, double lower, double upper)`	Check that the endpoints specify an interval and the end points bracket a root.
`protected void`	BaseAbstractUnivariateSolver.`verifyInterval(double lower, double upper)`	Check that the endpoints specify an interval.
`static void`	UnivariateSolverUtils.`verifyInterval(double lower, double upper)`	Check that the endpoints specify an interval.
`protected void`	BaseAbstractUnivariateSolver.`verifySequence(double lower, double initial, double upper)`	Check that `lower < initial < upper`.
`static void`	UnivariateSolverUtils.`verifySequence(double lower, double initial, double upper)`	Check that `lower < initial < upper`.

Constructors in org.hipparchus.analysis.solvers that throw MathIllegalArgumentException
Constructor	Description
`BracketingNthOrderBrentSolver(double relativeAccuracy, double absoluteAccuracy, double functionValueAccuracy, int maximalOrder)`	Construct a solver.
`BracketingNthOrderBrentSolver(double relativeAccuracy, double absoluteAccuracy, int maximalOrder)`	Construct a solver.
`BracketingNthOrderBrentSolver(double absoluteAccuracy, int maximalOrder)`	Construct a solver.
`FieldBracketingNthOrderBrentSolver(T relativeAccuracy, T absoluteAccuracy, T functionValueAccuracy, int maximalOrder)`	Construct a solver.

Uses of MathIllegalArgumentException in org.hipparchus.clustering

Methods in org.hipparchus.clustering that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`abstract List<? extends Cluster<T>>`	Clusterer.`cluster(Collection<T> points)`	Perform a cluster analysis on the given set of `Clusterable` instances.
`List<CentroidCluster<T>>`	FuzzyKMeansClusterer.`cluster(Collection<T> dataPoints)`	Performs Fuzzy K-Means cluster analysis.
`List<CentroidCluster<T>>`	KMeansPlusPlusClusterer.`cluster(Collection<T> points)`	Runs the K-means++ clustering algorithm.
`List<CentroidCluster<T>>`	MultiKMeansPlusPlusClusterer.`cluster(Collection<T> points)`	Runs the K-means++ clustering algorithm.

Constructors in org.hipparchus.clustering that throw MathIllegalArgumentException
Constructor	Description
`DBSCANClusterer(double eps, int minPts)`	Creates a new instance of a DBSCANClusterer.
`DBSCANClusterer(double eps, int minPts, DistanceMeasure measure)`	Creates a new instance of a DBSCANClusterer.
`FuzzyKMeansClusterer(int k, double fuzziness)`	Creates a new instance of a FuzzyKMeansClusterer.
`FuzzyKMeansClusterer(int k, double fuzziness, int maxIterations, DistanceMeasure measure)`	Creates a new instance of a FuzzyKMeansClusterer.
`FuzzyKMeansClusterer(int k, double fuzziness, int maxIterations, DistanceMeasure measure, double epsilon, RandomGenerator random)`	Creates a new instance of a FuzzyKMeansClusterer.

Uses of MathIllegalArgumentException in org.hipparchus.clustering.distance

Methods in org.hipparchus.clustering.distance that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	CanberraDistance.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.
`double`	ChebyshevDistance.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.
`double`	DistanceMeasure.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.
`double`	EarthMoversDistance.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.
`double`	EuclideanDistance.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.
`double`	ManhattanDistance.`compute(double[] a, double[] b)`	Compute the distance between two n-dimensional vectors.

Uses of MathIllegalArgumentException in org.hipparchus.complex

Methods in org.hipparchus.complex that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	RootsOfUnity.`computeRoots(int n)`	Computes the `n`-th roots of unity.
`StringBuffer`	ComplexFormat.`format(Object obj, StringBuffer toAppendTo, FieldPosition pos)`	Formats a object to produce a string.
`static ComplexFormat`	ComplexFormat.`getComplexFormat(String imaginaryCharacter, Locale locale)`	Returns the default complex format for the given locale.
`double`	RootsOfUnity.`getImaginary(int k)`	Get the imaginary part of the `k`-th `n`-th root of unity.
`static ComplexFormat`	ComplexFormat.`getInstance(String imaginaryCharacter, Locale locale)`	Deprecated. as of 1.4, replaced by `ComplexFormat.getComplexFormat(String, Locale)`
`double`	RootsOfUnity.`getReal(int k)`	Get the real part of the `k`-th `n`-th root of unity.
`List<Complex>`	Complex.`nthRoot(int n)`	Computes the n-th roots of this complex number.
`static Complex`	ComplexUtils.`polar2Complex(double r, double theta)`	Creates a complex number from the given polar representation.

Constructors in org.hipparchus.complex that throw MathIllegalArgumentException
Constructor	Description
`ComplexFormat(String imaginaryCharacter)`	Create an instance with a custom imaginary character, and the default number format for both real and imaginary parts.
`ComplexFormat(String imaginaryCharacter, NumberFormat format)`	Create an instance with a custom imaginary character, and a custom number format for both real and imaginary parts.
`ComplexFormat(String imaginaryCharacter, NumberFormat realFormat, NumberFormat imaginaryFormat)`	Create an instance with a custom imaginary character, a custom number format for the real part, and a custom number format for the imaginary part.
`Quaternion(double scalar, double[] v)`	Builds a quaternion from scalar and vector parts.

Uses of MathIllegalArgumentException in org.hipparchus.dfp

Methods in org.hipparchus.dfp that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`Dfp`	Dfp.`atan2(Dfp x)`	Two arguments arc tangent operation.
`Dfp`	Dfp.`linearCombination(double[] a, Dfp[] b)`	Compute a linear combination.
`Dfp`	Dfp.`linearCombination(Dfp[] a, Dfp[] b)`	Compute a linear combination.

Uses of MathIllegalArgumentException in org.hipparchus.distribution

Methods in org.hipparchus.distribution that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`int`	IntegerDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	RealDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	IntegerDistribution.`probability(int x0, int x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.
`double`	RealDistribution.`probability(double x0, double x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.
`double[][]`	MultivariateRealDistribution.`sample(int sampleSize)`	Generates a list of a random value vectors from the distribution.

Constructors in org.hipparchus.distribution that throw MathIllegalArgumentException
Constructor	Description
`EnumeratedDistribution(List<Pair<T,Double>> pmf)`	Create an enumerated distribution using the given probability mass function enumeration.

Uses of MathIllegalArgumentException in org.hipparchus.distribution.continuous

Methods in org.hipparchus.distribution.continuous that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	AbstractRealDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	CauchyDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	ConstantRealDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	EnumeratedRealDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	ExponentialDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	GumbelDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	LaplaceDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	LevyDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	LogisticDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	NormalDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	TriangularDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	UniformRealDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	AbstractRealDistribution.`probability(double x0, double x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.
`double`	LogNormalDistribution.`probability(double x0, double x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.
`double`	NormalDistribution.`probability(double x0, double x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.

Constructors in org.hipparchus.distribution.continuous that throw MathIllegalArgumentException
Constructor	Description
`CauchyDistribution(double median, double scale)`	Creates a Cauchy distribution.
`EnumeratedRealDistribution(double[] singletons, double[] probabilities)`	Create a discrete real-valued distribution using the given probability mass function enumeration.
`ExponentialDistribution(double mean)`	Create an exponential distribution with the given mean.
`FDistribution(double numeratorDegreesOfFreedom, double denominatorDegreesOfFreedom)`	Creates an F distribution using the given degrees of freedom.
`FDistribution(double numeratorDegreesOfFreedom, double denominatorDegreesOfFreedom, double inverseCumAccuracy)`	Creates an F distribution.
`GammaDistribution(double shape, double scale)`	Creates a new gamma distribution with specified values of the shape and scale parameters.
`GammaDistribution(double shape, double scale, double inverseCumAccuracy)`	Creates a Gamma distribution.
`GumbelDistribution(double mu, double beta)`	Build a new instance.
`LaplaceDistribution(double mu, double beta)`	Build a new instance.
`LogisticDistribution(double mu, double s)`	Build a new instance.
`LogNormalDistribution(double location, double shape)`	Create a log-normal distribution using the specified location and shape.
`LogNormalDistribution(double location, double shape, double inverseCumAccuracy)`	Creates a log-normal distribution.
`NakagamiDistribution(double mu, double omega)`	Build a new instance.
`NakagamiDistribution(double mu, double omega, double inverseAbsoluteAccuracy)`	Build a new instance.
`NormalDistribution(double mean, double sd)`	Create a normal distribution using the given mean, standard deviation.
`ParetoDistribution(double scale, double shape)`	Create a Pareto distribution using the specified scale and shape.
`ParetoDistribution(double scale, double shape, double inverseCumAccuracy)`	Creates a Pareto distribution.
`TDistribution(double degreesOfFreedom)`	Create a t distribution using the given degrees of freedom.
`TDistribution(double degreesOfFreedom, double inverseCumAccuracy)`	Create a t distribution using the given degrees of freedom and the specified inverse cumulative probability absolute accuracy.
`TriangularDistribution(double a, double c, double b)`	Creates a triangular real distribution using the given lower limit, upper limit, and mode.
`UniformRealDistribution(double lower, double upper)`	Create a uniform real distribution using the given lower and upper bounds.
`WeibullDistribution(double alpha, double beta)`	Create a Weibull distribution with the given shape and scale.

Uses of MathIllegalArgumentException in org.hipparchus.distribution.discrete

Methods in org.hipparchus.distribution.discrete that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`int`	AbstractIntegerDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`int`	GeometricDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`double`	AbstractIntegerDistribution.`probability(int x0, int x1)`	For a random variable `X` whose values are distributed according to this distribution, this method returns `P(x0 < X <= x1)`.

Constructors in org.hipparchus.distribution.discrete that throw MathIllegalArgumentException
Constructor	Description
`BinomialDistribution(int trials, double p)`	Create a binomial distribution with the given number of trials and probability of success.
`EnumeratedIntegerDistribution(int[] singletons, double[] probabilities)`	Create a discrete distribution using the given probability mass function definition.
`GeometricDistribution(double p)`	Create a geometric distribution with the given probability of success.
`HypergeometricDistribution(int populationSize, int numberOfSuccesses, int sampleSize)`	Construct a new hypergeometric distribution with the specified population size, number of successes in the population, and sample size.
`PascalDistribution(int r, double p)`	Create a Pascal distribution with the given number of successes and probability of success.
`PoissonDistribution(double p)`	Creates a new Poisson distribution with specified mean.
`PoissonDistribution(double p, double epsilon)`	Creates a new Poisson distribution with the specified mean and convergence criterion.
`PoissonDistribution(double p, double epsilon, int maxIterations)`	Creates a new Poisson distribution with specified mean, convergence criterion and maximum number of iterations.
`UniformIntegerDistribution(int lower, int upper)`	Creates a new uniform integer distribution using the given lower and upper bounds (both inclusive).
`ZipfDistribution(int numberOfElements, double exponent)`	Create a new Zipf distribution with the given number of elements and exponent.

Uses of MathIllegalArgumentException in org.hipparchus.distribution.multivariate

Methods in org.hipparchus.distribution.multivariate that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	MultivariateNormalDistribution.`density(double[] vals)`	Returns the probability density function (PDF) of this distribution evaluated at the specified point `x`.

Constructors in org.hipparchus.distribution.multivariate that throw MathIllegalArgumentException
Constructor	Description
`MixtureMultivariateNormalDistribution(RandomGenerator rng, List<Pair<Double,MultivariateNormalDistribution>> components)`	Creates a mixture model from a list of distributions and their associated weights.
`MultivariateNormalDistribution(double[] means, double[][] covariances)`	Creates a multivariate normal distribution with the given mean vector and covariance matrix.
`MultivariateNormalDistribution(RandomGenerator rng, double[] means, double[][] covariances)`	Creates a multivariate normal distribution with the given mean vector and covariance matrix.

Uses of MathIllegalArgumentException in org.hipparchus.filtering.kalman

Methods in org.hipparchus.filtering.kalman that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected void`	AbstractKalmanFilter.`correct(T measurement, RealMatrix stm, RealVector innovation, RealMatrix h, RealMatrix s)`	Perform correction step.

Uses of MathIllegalArgumentException in org.hipparchus.fraction

Methods in org.hipparchus.fraction that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`StringBuffer`	FractionFormat.`format(Object obj, StringBuffer toAppendTo, FieldPosition pos)`	Formats an object and appends the result to a StringBuffer.

Constructors in org.hipparchus.fraction that throw MathIllegalArgumentException
Constructor	Description
`BigFraction(double value)`	Create a fraction given the double value.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.threed

Methods in org.hipparchus.geometry.euclidean.threed that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	FieldLine.`reset(FieldVector3D<T> p1, FieldVector3D<T> p2)`	Reset the instance as if built from two points.
`void`	Line.`reset(Vector3D p1, Vector3D p2)`	Reset the instance as if built from two points.

Constructors in org.hipparchus.geometry.euclidean.threed that throw MathIllegalArgumentException
Constructor	Description
`FieldLine(FieldVector3D<T> p1, FieldVector3D<T> p2, double tolerance)`	Build a line from two points.
`FieldRotation(FieldVector3D<T> axis, T angle)`	Deprecated. as of 3.6, replaced with `FieldRotation(FieldVector3D, RealFieldElement, RotationConvention)`
`FieldRotation(FieldVector3D<T> axis, T angle, RotationConvention convention)`	Build a rotation from an axis and an angle.
`FieldRotation(T[][] m, double threshold)`	Build a rotation from a 3X3 matrix.
`FieldVector3D(T[] v)`	Simple constructor.
`Line(Vector3D p1, Vector3D p2, double tolerance)`	Build a line from two points.
`Rotation(double[][] m, double threshold)`	Build a rotation from a 3X3 matrix.
`Rotation(Vector3D axis, double angle)`	Deprecated. as of 3.6, replaced with `Rotation(Vector3D, double, RotationConvention)`
`Rotation(Vector3D axis, double angle, RotationConvention convention)`	Build a rotation from an axis and an angle.
`SubLine(Segment segment)`	Create a sub-line from a segment.
`SubLine(Vector3D start, Vector3D end, double tolerance)`	Create a sub-line from two endpoints.
`Vector3D(double[] v)`	Simple constructor.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.twod

Methods in org.hipparchus.geometry.euclidean.twod that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static Transform<Euclidean2D,Euclidean1D>`	Line.`getTransform(double cXX, double cYX, double cXY, double cYY, double cX1, double cY1)`	Get a `Transform` embedding an affine transform.

Constructors in org.hipparchus.geometry.euclidean.twod that throw MathIllegalArgumentException
Constructor	Description
`Vector2D(double[] v)`	Simple constructor.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.twod.hull

Methods in org.hipparchus.geometry.euclidean.twod.hull that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`Region<Euclidean2D>`	ConvexHull2D.`createRegion()`	Returns a new region that is enclosed by the convex hull.

Constructors in org.hipparchus.geometry.euclidean.twod.hull that throw MathIllegalArgumentException
Constructor	Description
`ConvexHull2D(Vector2D[] vertices, double tolerance)`	Simple constructor.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.hull

Methods in org.hipparchus.geometry.hull that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`Region<S>`	ConvexHull.`createRegion()`	Returns a new region that is enclosed by the convex hull.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.spherical.oned

Subclasses of MathIllegalArgumentException in org.hipparchus.geometry.spherical.oned
Modifier and Type	Class	Description
`static class`	`ArcsSet.InconsistentStateAt2PiWrapping`	Specialized exception for inconsistent BSP tree state inconsistency.

Methods in org.hipparchus.geometry.spherical.oned that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static void`	Sphere1D.`checkTolerance(double tolerance)`	Check tolerance against `Sphere1D.SMALLEST_TOLERANCE`.

Constructors in org.hipparchus.geometry.spherical.oned that throw MathIllegalArgumentException
Constructor	Description
`Arc(double lower, double upper, double tolerance)`	Simple constructor.
`ArcsSet(double tolerance)`	Build an arcs set representing the whole circle.
`ArcsSet(double lower, double upper, double tolerance)`	Build an arcs set corresponding to a single arc.
`ArcsSet(Collection<SubHyperplane<Sphere1D>> boundary, double tolerance)`	Build an arcs set from a Boundary REPresentation (B-rep).
`ArcsSet(BSPTree<Sphere1D> tree, double tolerance)`	Build an arcs set from an inside/outside BSP tree.
`LimitAngle(S1Point location, boolean direct, double tolerance)`	Simple constructor.

Uses of MathIllegalArgumentException in org.hipparchus.geometry.spherical.twod

Methods in org.hipparchus.geometry.spherical.twod that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static void`	Sphere2D.`checkTolerance(double tolerance)`	Check tolerance against `Sphere2D.SMALLEST_TOLERANCE`.

Constructors in org.hipparchus.geometry.spherical.twod that throw MathIllegalArgumentException
Constructor	Description
`Circle(Vector3D pole, double tolerance)`	Build a great circle from its pole.
`Circle(S2Point first, S2Point second, double tolerance)`	Build a great circle from two non-aligned points.
`S2Point(double theta, double phi)`	Simple constructor.
`SphericalPolygonsSet(double tolerance)`	Build a polygons set representing the whole real 2-sphere.
`SphericalPolygonsSet(double hyperplaneThickness, S2Point... vertices)`	Build a polygon from a simple list of vertices.
`SphericalPolygonsSet(Collection<SubHyperplane<Sphere2D>> boundary, double tolerance)`	Build a polygons set from a Boundary REPresentation (B-rep).
`SphericalPolygonsSet(Vector3D pole, double tolerance)`	Build a polygons set representing a hemisphere.
`SphericalPolygonsSet(Vector3D center, Vector3D meridian, double outsideRadius, int n, double tolerance)`	Build a polygons set representing a regular polygon.
`SphericalPolygonsSet(BSPTree<Sphere2D> tree, double tolerance)`	Build a polygons set from a BSP tree.

Uses of MathIllegalArgumentException in org.hipparchus.linear

Methods in org.hipparchus.linear that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`FieldMatrix<T>`	AbstractFieldMatrix.`add(FieldMatrix<T> m)`	Compute the sum of this and m.
`RealMatrix`	AbstractRealMatrix.`add(RealMatrix m)`	Returns the sum of `this` and `m`.
`Array2DRowFieldMatrix<T>`	Array2DRowFieldMatrix.`add(Array2DRowFieldMatrix<T> m)`	Add `m` to this matrix.
`Array2DRowRealMatrix`	Array2DRowRealMatrix.`add(Array2DRowRealMatrix m)`	Compute the sum of `this` and `m`.
`ArrayFieldVector<T>`	ArrayFieldVector.`add(ArrayFieldVector<T> v)`	Compute the sum of `this` and `v`.
`FieldVector<T>`	ArrayFieldVector.`add(FieldVector<T> v)`	Compute the sum of `this` and `v`.
`ArrayRealVector`	ArrayRealVector.`add(RealVector v)`	Compute the sum of this vector and `v`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`add(BlockFieldMatrix<T> m)`	Compute the sum of `this` and `m`.
`FieldMatrix<T>`	BlockFieldMatrix.`add(FieldMatrix<T> m)`	Compute the sum of this and m.
`BlockRealMatrix`	BlockRealMatrix.`add(BlockRealMatrix m)`	Compute the sum of this matrix and `m`.
`BlockRealMatrix`	BlockRealMatrix.`add(RealMatrix m)`	Returns the sum of `this` and `m`.
`DiagonalMatrix`	DiagonalMatrix.`add(DiagonalMatrix m)`	Compute the sum of `this` and `m`.
`FieldMatrix<T>`	FieldMatrix.`add(FieldMatrix<T> m)`	Compute the sum of this and m.
`FieldVector<T>`	FieldVector.`add(FieldVector<T> v)`	Compute the sum of `this` and `v`.
`OpenMapRealMatrix`	OpenMapRealMatrix.`add(OpenMapRealMatrix m)`	Compute the sum of this matrix and `m`.
`OpenMapRealVector`	OpenMapRealVector.`add(OpenMapRealVector v)`	Optimized method to add two OpenMapRealVectors.
`RealVector`	OpenMapRealVector.`add(RealVector v)`	Compute the sum of this vector and `v`.
`RealMatrix`	RealMatrix.`add(RealMatrix m)`	Returns the sum of `this` and `m`.
`RealVector`	RealVector.`add(RealVector v)`	Compute the sum of this vector and `v`.
`FieldVector<T>`	SparseFieldVector.`add(FieldVector<T> v)`	Compute the sum of `this` and `v`.
`FieldVector<T>`	SparseFieldVector.`add(SparseFieldVector<T> v)`	Optimized method to add sparse vectors.
`abstract void`	AbstractFieldMatrix.`addToEntry(int row, int column, T increment)`	Change an entry in the specified row and column.
`void`	AbstractRealMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	Array2DRowFieldMatrix.`addToEntry(int row, int column, T increment)`	Change an entry in the specified row and column.
`void`	Array2DRowRealMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	ArrayRealVector.`addToEntry(int index, double increment)`	Change an entry at the specified index.
`void`	BlockFieldMatrix.`addToEntry(int row, int column, T increment)`	Change an entry in the specified row and column.
`void`	BlockRealMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	DiagonalMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	FieldMatrix.`addToEntry(int row, int column, T increment)`	Change an entry in the specified row and column.
`void`	OpenMapRealMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	RealMatrix.`addToEntry(int row, int column, double increment)`	Adds (in place) the specified value to the specified entry of `this` matrix.
`void`	RealVector.`addToEntry(int index, double increment)`	Change an entry at the specified index.
`protected void`	AbstractFieldMatrix.`checkAdditionCompatible(FieldMatrix<T> m)`	Check if a matrix is addition compatible with the instance.
`static void`	MatrixUtils.`checkAdditionCompatible(AnyMatrix left, AnyMatrix right)`	Check if matrices are addition compatible.
`protected void`	AbstractFieldMatrix.`checkColumnIndex(int column)`	Check if a column index is valid.
`static void`	MatrixUtils.`checkColumnIndex(AnyMatrix m, int column)`	Check if a column index is valid.
`protected void`	RealVector.`checkIndex(int index)`	Check if an index is valid.
`protected void`	RealVector.`checkIndices(int start, int end)`	Checks that the indices of a subvector are valid.
`static void`	MatrixUtils.`checkMatrixIndex(AnyMatrix m, int row, int column)`	Check if matrix indices are valid.
`protected void`	AbstractFieldMatrix.`checkMultiplicationCompatible(FieldMatrix<T> m)`	Check if a matrix is multiplication compatible with the instance.
`static void`	MatrixUtils.`checkMultiplicationCompatible(AnyMatrix left, AnyMatrix right)`	Check if matrices are multiplication compatible
`protected static void`	IterativeLinearSolver.`checkParameters(RealLinearOperator a, RealVector b, RealVector x0)`	Performs all dimension checks on the parameters of `solve` and `solveInPlace`, and throws an exception if one of the checks fails.
`protected static void`	PreconditionedIterativeLinearSolver.`checkParameters(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x0)`	Performs all dimension checks on the parameters of `solve` and `solveInPlace`, and throws an exception if one of the checks fails.
`protected void`	AbstractFieldMatrix.`checkRowIndex(int row)`	Check if a row index is valid.
`static void`	MatrixUtils.`checkRowIndex(AnyMatrix m, int row)`	Check if a row index is valid.
`static void`	MatrixUtils.`checkSameColumnDimension(AnyMatrix left, AnyMatrix right)`	Check if matrices have the same number of columns.
`static void`	MatrixUtils.`checkSameRowDimension(AnyMatrix left, AnyMatrix right)`	Check if matrices have the same number of rows.
`protected void`	AbstractFieldMatrix.`checkSubMatrixIndex(int[] selectedRows, int[] selectedColumns)`	Check if submatrix ranges indices are valid.
`protected void`	AbstractFieldMatrix.`checkSubMatrixIndex(int startRow, int endRow, int startColumn, int endColumn)`	Check if submatrix ranges indices are valid.
`static void`	MatrixUtils.`checkSubMatrixIndex(AnyMatrix m, int[] selectedRows, int[] selectedColumns)`	Check if submatrix ranges indices are valid.
`static void`	MatrixUtils.`checkSubMatrixIndex(AnyMatrix m, int startRow, int endRow, int startColumn, int endColumn)`	Check if submatrix ranges indices are valid.
`protected void`	AbstractFieldMatrix.`checkSubtractionCompatible(FieldMatrix<T> m)`	Check if a matrix is subtraction compatible with the instance.
`static void`	MatrixUtils.`checkSubtractionCompatible(AnyMatrix left, AnyMatrix right)`	Check if matrices are subtraction compatible
`protected void`	ArrayFieldVector.`checkVectorDimensions(int n)`	Check if instance dimension is equal to some expected value.
`protected void`	ArrayFieldVector.`checkVectorDimensions(FieldVector<T> v)`	Check if instance and specified vectors have the same dimension.
`protected void`	ArrayRealVector.`checkVectorDimensions(int n)`	Check if instance dimension is equal to some expected value.
`protected void`	ArrayRealVector.`checkVectorDimensions(RealVector v)`	Check if instance and specified vectors have the same dimension.
`protected void`	RealVector.`checkVectorDimensions(int n)`	Check if instance dimension is equal to some expected value.
`protected void`	RealVector.`checkVectorDimensions(RealVector v)`	Check if instance and specified vectors have the same dimension.
`protected void`	SparseFieldVector.`checkVectorDimensions(int n)`	Check if instance dimension is equal to some expected value.
`ArrayRealVector`	ArrayRealVector.`combine(double a, double b, RealVector y)`	Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
`RealVector`	RealVector.`combine(double a, double b, RealVector y)`	Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
`ArrayRealVector`	ArrayRealVector.`combineToSelf(double a, double b, RealVector y)`	Updates `this` with the linear combination of `this` and `y`.
`RealVector`	RealVector.`combineToSelf(double a, double b, RealVector y)`	Updates `this` with the linear combination of `this` and `y`.
`void`	AbstractFieldMatrix.`copySubMatrix(int[] selectedRows, int[] selectedColumns, T[][] destination)`	Copy a submatrix.
`void`	AbstractFieldMatrix.`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, T[][] destination)`	Copy a submatrix.
`void`	AbstractRealMatrix.`copySubMatrix(int[] selectedRows, int[] selectedColumns, double[][] destination)`	Copy a submatrix.
`void`	AbstractRealMatrix.`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, double[][] destination)`	Copy a submatrix.
`void`	FieldMatrix.`copySubMatrix(int[] selectedRows, int[] selectedColumns, T[][] destination)`	Copy a submatrix.
`void`	FieldMatrix.`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, T[][] destination)`	Copy a submatrix.
`void`	RealMatrix.`copySubMatrix(int[] selectedRows, int[] selectedColumns, double[][] destination)`	Copy a submatrix.
`void`	RealMatrix.`copySubMatrix(int startRow, int endRow, int startColumn, int endColumn, double[][] destination)`	Copy a submatrix.
`double`	RealVector.`cosine(RealVector v)`	Computes the cosine of the angle between this vector and the argument.
`static JacobiPreconditioner`	JacobiPreconditioner.`create(RealLinearOperator a)`	Creates a new instance of this class.
`static <T extends FieldElement<T>> FieldMatrix<T>`	MatrixUtils.`createColumnFieldMatrix(T[] columnData)`	Creates a column `FieldMatrix` using the data from the input array.
`static RealMatrix`	MatrixUtils.`createColumnRealMatrix(double[] columnData)`	Creates a column `RealMatrix` using the data from the input array.
`static <T extends FieldElement<T>> FieldMatrix<T>`	MatrixUtils.`createFieldMatrix(T[][] data)`	Returns a `FieldMatrix` whose entries are the the values in the the input array.
`static <T extends FieldElement<T>> FieldVector<T>`	MatrixUtils.`createFieldVector(T[] data)`	Creates a `FieldVector` using the data from the input array.
`abstract FieldMatrix<T>`	AbstractFieldMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new FieldMatrix of the same type as the instance with the supplied row and column dimensions.
`abstract RealMatrix`	AbstractRealMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`FieldMatrix<T>`	Array2DRowFieldMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new FieldMatrix of the same type as the instance with the supplied row and column dimensions.
`RealMatrix`	Array2DRowRealMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`FieldMatrix<T>`	BlockFieldMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new FieldMatrix of the same type as the instance with the supplied row and column dimensions.
`BlockRealMatrix`	BlockRealMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`RealMatrix`	DiagonalMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`FieldMatrix<T>`	FieldMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new FieldMatrix of the same type as the instance with the supplied row and column dimensions.
`OpenMapRealMatrix`	OpenMapRealMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`RealMatrix`	RealMatrix.`createMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`static RealMatrix`	MatrixUtils.`createRealMatrix(double[][] data)`	Returns a `RealMatrix` whose entries are the the values in the the input array.
`static RealVector`	MatrixUtils.`createRealVector(double[] data)`	Creates a `RealVector` using the data from the input array.
`static <T extends FieldElement<T>> FieldMatrix<T>`	MatrixUtils.`createRowFieldMatrix(T[] rowData)`	Create a row `FieldMatrix` using the data from the input array.
`static RealMatrix`	MatrixUtils.`createRowRealMatrix(double[] rowData)`	Create a row `RealMatrix` using the data from the input array.
`DecompositionSolver`	MatrixDecomposer.`decompose(RealMatrix a)`	Get a solver for finding the A × X = B solution in least square sense.
`T`	ArrayFieldVector.`dotProduct(ArrayFieldVector<T> v)`	Compute the dot product.
`T`	ArrayFieldVector.`dotProduct(FieldVector<T> v)`	Compute the dot product.
`double`	ArrayRealVector.`dotProduct(RealVector v)`	Compute the dot product of this vector with `v`.
`T`	FieldVector.`dotProduct(FieldVector<T> v)`	Compute the dot product.
`double`	RealVector.`dotProduct(RealVector v)`	Compute the dot product of this vector with `v`.
`T`	SparseFieldVector.`dotProduct(FieldVector<T> v)`	Compute the dot product.
`ArrayFieldVector<T>`	ArrayFieldVector.`ebeDivide(ArrayFieldVector<T> v)`	Element-by-element division.
`FieldVector<T>`	ArrayFieldVector.`ebeDivide(FieldVector<T> v)`	Element-by-element division.
`ArrayRealVector`	ArrayRealVector.`ebeDivide(RealVector v)`	Element-by-element division.
`FieldVector<T>`	FieldVector.`ebeDivide(FieldVector<T> v)`	Element-by-element division.
`OpenMapRealVector`	OpenMapRealVector.`ebeDivide(RealVector v)`	Element-by-element division.
`abstract RealVector`	RealVector.`ebeDivide(RealVector v)`	Element-by-element division.
`FieldVector<T>`	SparseFieldVector.`ebeDivide(FieldVector<T> v)`	Element-by-element division.
`ArrayFieldVector<T>`	ArrayFieldVector.`ebeMultiply(ArrayFieldVector<T> v)`	Element-by-element multiplication.
`FieldVector<T>`	ArrayFieldVector.`ebeMultiply(FieldVector<T> v)`	Element-by-element multiplication.
`ArrayRealVector`	ArrayRealVector.`ebeMultiply(RealVector v)`	Element-by-element multiplication.
`FieldVector<T>`	FieldVector.`ebeMultiply(FieldVector<T> v)`	Element-by-element multiplication.
`OpenMapRealVector`	OpenMapRealVector.`ebeMultiply(RealVector v)`	Element-by-element multiplication.
`abstract RealVector`	RealVector.`ebeMultiply(RealVector v)`	Element-by-element multiplication.
`FieldVector<T>`	SparseFieldVector.`ebeMultiply(FieldVector<T> v)`	Element-by-element multiplication.
`protected static <T extends FieldElement<T>> Field<T>`	AbstractFieldMatrix.`extractField(T[] d)`	Get the elements type from an array.
`protected static <T extends FieldElement<T>> Field<T>`	AbstractFieldMatrix.`extractField(T[][] d)`	Get the elements type from an array.
`T[]`	AbstractFieldMatrix.`getColumn(int column)`	Get the entries in column number `col` as an array.
`double[]`	AbstractRealMatrix.`getColumn(int column)`	Get the entries at the given column index as an array.
`T[]`	BlockFieldMatrix.`getColumn(int column)`	Get the entries in column number `col` as an array.
`double[]`	BlockRealMatrix.`getColumn(int column)`	Get the entries at the given column index as an array.
`T[]`	FieldMatrix.`getColumn(int column)`	Get the entries in column number `col` as an array.
`double[]`	RealMatrix.`getColumn(int column)`	Get the entries at the given column index as an array.
`FieldMatrix<T>`	AbstractFieldMatrix.`getColumnMatrix(int column)`	Get the entries in column number `column` as a column matrix.
`RealMatrix`	AbstractRealMatrix.`getColumnMatrix(int column)`	Get the entries at the given column index as a column matrix.
`FieldMatrix<T>`	BlockFieldMatrix.`getColumnMatrix(int column)`	Get the entries in column number `column` as a column matrix.
`BlockRealMatrix`	BlockRealMatrix.`getColumnMatrix(int column)`	Get the entries at the given column index as a column matrix.
`FieldMatrix<T>`	FieldMatrix.`getColumnMatrix(int column)`	Get the entries in column number `column` as a column matrix.
`RealMatrix`	RealMatrix.`getColumnMatrix(int column)`	Get the entries at the given column index as a column matrix.
`FieldVector<T>`	AbstractFieldMatrix.`getColumnVector(int column)`	Returns the entries in column number `column` as a vector.
`RealVector`	AbstractRealMatrix.`getColumnVector(int column)`	Get the entries at the given column index as a vector.
`FieldVector<T>`	BlockFieldMatrix.`getColumnVector(int column)`	Returns the entries in column number `column` as a vector.
`RealVector`	BlockRealMatrix.`getColumnVector(int column)`	Get the entries at the given column index as a vector.
`FieldVector<T>`	FieldMatrix.`getColumnVector(int column)`	Returns the entries in column number `column` as a vector.
`RealVector`	RealMatrix.`getColumnVector(int column)`	Get the entries at the given column index as a vector.
`double`	ArrayRealVector.`getDistance(RealVector v)`	Distance between two vectors.
`double`	OpenMapRealVector.`getDistance(OpenMapRealVector v)`	Optimized method to compute distance.
`double`	OpenMapRealVector.`getDistance(RealVector v)`	Distance between two vectors.
`double`	RealVector.`getDistance(RealVector v)`	Distance between two vectors.
`abstract T`	AbstractFieldMatrix.`getEntry(int row, int column)`	Returns the entry in the specified row and column.
`abstract double`	AbstractRealMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`T`	Array2DRowFieldMatrix.`getEntry(int row, int column)`	Returns the entry in the specified row and column.
`double`	Array2DRowRealMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`double`	ArrayRealVector.`getEntry(int index)`	Return the entry at the specified index.
`T`	BlockFieldMatrix.`getEntry(int row, int column)`	Returns the entry in the specified row and column.
`double`	BlockRealMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`double`	DiagonalMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`T`	FieldMatrix.`getEntry(int row, int column)`	Returns the entry in the specified row and column.
`T`	FieldVector.`getEntry(int index)`	Returns the entry in the specified index.
`double`	OpenMapRealMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`double`	OpenMapRealVector.`getEntry(int index)`	Return the entry at the specified index.
`double`	RealMatrix.`getEntry(int row, int column)`	Get the entry in the specified row and column.
`abstract double`	RealVector.`getEntry(int index)`	Return the entry at the specified index.
`T`	SparseFieldVector.`getEntry(int index)`	Returns the entry in the specified index.
`RealMatrix`	DecompositionSolver.`getInverse()`	Get the pseudo-inverse of the decomposed matrix.
`double`	ArrayRealVector.`getL1Distance(RealVector v)`	Distance between two vectors.
`double`	OpenMapRealVector.`getL1Distance(OpenMapRealVector v)`	Distance between two vectors.
`double`	OpenMapRealVector.`getL1Distance(RealVector v)`	Distance between two vectors.
`double`	RealVector.`getL1Distance(RealVector v)`	Distance between two vectors.
`double`	ArrayRealVector.`getLInfDistance(RealVector v)`	Distance between two vectors.
`double`	OpenMapRealVector.`getLInfDistance(RealVector v)`	Distance between two vectors.
`double`	RealVector.`getLInfDistance(RealVector v)`	Distance between two vectors.
`T[]`	AbstractFieldMatrix.`getRow(int row)`	Get the entries in row number `row` as an array.
`double[]`	AbstractRealMatrix.`getRow(int row)`	Get the entries at the given row index.
`T[]`	Array2DRowFieldMatrix.`getRow(int row)`	Get the entries in row number `row` as an array.
`double[]`	Array2DRowRealMatrix.`getRow(int row)`	Get the entries at the given row index.
`T[]`	BlockFieldMatrix.`getRow(int row)`	Get the entries in row number `row` as an array.
`double[]`	BlockRealMatrix.`getRow(int row)`	Get the entries at the given row index.
`T[]`	FieldMatrix.`getRow(int row)`	Get the entries in row number `row` as an array.
`double[]`	RealMatrix.`getRow(int row)`	Get the entries at the given row index.
`FieldMatrix<T>`	AbstractFieldMatrix.`getRowMatrix(int row)`	Get the entries in row number `row` as a row matrix.
`RealMatrix`	AbstractRealMatrix.`getRowMatrix(int row)`	Get the entries at the given row index as a row matrix.
`FieldMatrix<T>`	BlockFieldMatrix.`getRowMatrix(int row)`	Get the entries in row number `row` as a row matrix.
`BlockRealMatrix`	BlockRealMatrix.`getRowMatrix(int row)`	Get the entries at the given row index as a row matrix.
`FieldMatrix<T>`	FieldMatrix.`getRowMatrix(int row)`	Get the entries in row number `row` as a row matrix.
`RealMatrix`	RealMatrix.`getRowMatrix(int row)`	Get the entries at the given row index as a row matrix.
`FieldVector<T>`	AbstractFieldMatrix.`getRowVector(int row)`	Get the entries in row number `row` as a vector.
`RealVector`	AbstractRealMatrix.`getRowVector(int row)`	Returns the entries in row number `row` as a vector.
`FieldVector<T>`	BlockFieldMatrix.`getRowVector(int row)`	Get the entries in row number `row` as a vector.
`RealVector`	BlockRealMatrix.`getRowVector(int row)`	Returns the entries in row number `row` as a vector.
`FieldVector<T>`	FieldMatrix.`getRowVector(int row)`	Get the entries in row number `row` as a vector.
`RealVector`	RealMatrix.`getRowVector(int row)`	Returns the entries in row number `row` as a vector.
`FieldMatrix<T>`	AbstractFieldMatrix.`getSubMatrix(int[] selectedRows, int[] selectedColumns)`	Get a submatrix.
`FieldMatrix<T>`	AbstractFieldMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Get a submatrix.
`RealMatrix`	AbstractRealMatrix.`getSubMatrix(int[] selectedRows, int[] selectedColumns)`	Gets a submatrix.
`RealMatrix`	AbstractRealMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Gets a submatrix.
`FieldMatrix<T>`	Array2DRowFieldMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Get a submatrix.
`RealMatrix`	Array2DRowRealMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Gets a submatrix.
`FieldMatrix<T>`	BlockFieldMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Get a submatrix.
`BlockRealMatrix`	BlockRealMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Gets a submatrix.
`FieldMatrix<T>`	FieldMatrix.`getSubMatrix(int[] selectedRows, int[] selectedColumns)`	Get a submatrix.
`FieldMatrix<T>`	FieldMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Get a submatrix.
`RealMatrix`	RealMatrix.`getSubMatrix(int[] selectedRows, int[] selectedColumns)`	Gets a submatrix.
`RealMatrix`	RealMatrix.`getSubMatrix(int startRow, int endRow, int startColumn, int endColumn)`	Gets a submatrix.
`FieldVector<T>`	ArrayFieldVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`RealVector`	ArrayRealVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`FieldVector<T>`	FieldVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`OpenMapRealVector`	OpenMapRealVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`abstract RealVector`	RealVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`FieldVector<T>`	SparseFieldVector.`getSubVector(int index, int n)`	Get a subvector from consecutive elements.
`T`	AbstractFieldMatrix.`getTrace()`	Returns the trace of the matrix (the sum of the elements on the main diagonal).
`double`	AbstractRealMatrix.`getTrace()`	Returns the trace of the matrix (the sum of the elements on the main diagonal).
`T`	FieldMatrix.`getTrace()`	Returns the trace of the matrix (the sum of the elements on the main diagonal).
`double`	RealMatrix.`getTrace()`	Returns the trace of the matrix (the sum of the elements on the main diagonal).
`DiagonalMatrix`	DiagonalMatrix.`inverse()`	Computes the inverse of this diagonal matrix.
`DiagonalMatrix`	DiagonalMatrix.`inverse(double threshold)`	Computes the inverse of this diagonal matrix.
`static RealMatrix`	MatrixUtils.`inverse(RealMatrix matrix)`	Computes the inverse of the given matrix.
`static RealMatrix`	MatrixUtils.`inverse(RealMatrix matrix, double threshold)`	Computes the inverse of the given matrix.
`FieldMatrix<T>`	AbstractFieldMatrix.`multiply(FieldMatrix<T> m)`	Postmultiply this matrix by `m`.
`RealMatrix`	AbstractRealMatrix.`multiply(RealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`Array2DRowFieldMatrix<T>`	Array2DRowFieldMatrix.`multiply(Array2DRowFieldMatrix<T> m)`	Postmultiplying this matrix by `m`.
`Array2DRowRealMatrix`	Array2DRowRealMatrix.`multiply(Array2DRowRealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`multiply(BlockFieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m`.
`FieldMatrix<T>`	BlockFieldMatrix.`multiply(FieldMatrix<T> m)`	Postmultiply this matrix by `m`.
`BlockRealMatrix`	BlockRealMatrix.`multiply(BlockRealMatrix m)`	Returns the result of postmultiplying this by `m`.
`BlockRealMatrix`	BlockRealMatrix.`multiply(RealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`DiagonalMatrix`	DiagonalMatrix.`multiply(DiagonalMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`RealMatrix`	DiagonalMatrix.`multiply(RealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`FieldMatrix<T>`	FieldMatrix.`multiply(FieldMatrix<T> m)`	Postmultiply this matrix by `m`.
`OpenMapRealMatrix`	OpenMapRealMatrix.`multiply(OpenMapRealMatrix m)`	Postmultiply this matrix by `m`.
`RealMatrix`	OpenMapRealMatrix.`multiply(RealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`RealMatrix`	RealMatrix.`multiply(RealMatrix m)`	Returns the result of postmultiplying `this` by `m`.
`abstract void`	AbstractFieldMatrix.`multiplyEntry(int row, int column, T factor)`	Change an entry in the specified row and column.
`void`	AbstractRealMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`void`	Array2DRowFieldMatrix.`multiplyEntry(int row, int column, T factor)`	Change an entry in the specified row and column.
`void`	Array2DRowRealMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`void`	BlockFieldMatrix.`multiplyEntry(int row, int column, T factor)`	Change an entry in the specified row and column.
`void`	BlockRealMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`void`	DiagonalMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`void`	FieldMatrix.`multiplyEntry(int row, int column, T factor)`	Change an entry in the specified row and column.
`void`	OpenMapRealMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`void`	RealMatrix.`multiplyEntry(int row, int column, double factor)`	Multiplies (in place) the specified entry of `this` matrix by the specified value.
`FieldMatrix<T>`	Array2DRowFieldMatrix.`multiplyTransposed(Array2DRowFieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m^T`.
`RealMatrix`	Array2DRowRealMatrix.`multiplyTransposed(Array2DRowRealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`multiplyTransposed(BlockFieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m^T`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`multiplyTransposed(FieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m^T`.
`BlockRealMatrix`	BlockRealMatrix.`multiplyTransposed(BlockRealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`BlockRealMatrix`	BlockRealMatrix.`multiplyTransposed(RealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`DiagonalMatrix`	DiagonalMatrix.`multiplyTransposed(DiagonalMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`RealMatrix`	DiagonalMatrix.`multiplyTransposed(RealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`default FieldMatrix<T>`	FieldMatrix.`multiplyTransposed(FieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m^T`.
`RealMatrix`	OpenMapRealMatrix.`multiplyTransposed(RealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`default RealMatrix`	RealMatrix.`multiplyTransposed(RealMatrix m)`	Returns the result of postmultiplying `this` by `m^T`.
`FieldMatrix<T>`	SparseFieldMatrix.`multiplyTransposed(FieldMatrix<T> m)`	Returns the result of postmultiplying `this` by `m^T`.
`FieldVector<T>`	AbstractFieldMatrix.`operate(FieldVector<T> v)`	Returns the result of multiplying this by the vector `v`.
`T[]`	AbstractFieldMatrix.`operate(T[] v)`	Returns the result of multiplying this by the vector `v`.
`double[]`	AbstractRealMatrix.`operate(double[] v)`	Returns the result of multiplying this by the vector `v`.
`RealVector`	AbstractRealMatrix.`operate(RealVector v)`	Returns the result of multiplying this by the vector `v`.
`T[]`	Array2DRowFieldMatrix.`operate(T[] v)`	Returns the result of multiplying this by the vector `v`.
`double[]`	Array2DRowRealMatrix.`operate(double[] v)`	Returns the result of multiplying this by the vector `v`.
`T[]`	BlockFieldMatrix.`operate(T[] v)`	Returns the result of multiplying this by the vector `v`.
`double[]`	BlockRealMatrix.`operate(double[] v)`	Returns the result of multiplying this by the vector `v`.
`double[]`	DiagonalMatrix.`operate(double[] v)`	Returns the result of multiplying this by the vector `v`.
`FieldVector<T>`	FieldMatrix.`operate(FieldVector<T> v)`	Returns the result of multiplying this by the vector `v`.
`T[]`	FieldMatrix.`operate(T[] v)`	Returns the result of multiplying this by the vector `v`.
`RealVector`	RealLinearOperator.`operate(RealVector x)`	Returns the result of multiplying `this` by the vector `x`.
`double[]`	RealMatrix.`operate(double[] v)`	Returns the result of multiplying this by the vector `v`.
`RealVector`	RealMatrix.`operate(RealVector v)`	Returns the result of multiplying this by the vector `v`.
`default RealVector`	RealLinearOperator.`operateTranspose(RealVector x)`	Returns the result of multiplying the transpose of `this` operator by the vector `x` (optional operation).
`FieldMatrix<T>`	AbstractFieldMatrix.`power(int p)`	Returns the result multiplying this with itself `p` times.
`RealMatrix`	AbstractRealMatrix.`power(int p)`	Returns the result of multiplying `this` with itself `p` times.
`FieldMatrix<T>`	FieldMatrix.`power(int p)`	Returns the result multiplying this with itself `p` times.
`RealMatrix`	RealMatrix.`power(int p)`	Returns the result of multiplying `this` with itself `p` times.
`FieldMatrix<T>`	AbstractFieldMatrix.`preMultiply(FieldMatrix<T> m)`	Premultiply this matrix by `m`.
`FieldVector<T>`	AbstractFieldMatrix.`preMultiply(FieldVector<T> v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`	AbstractFieldMatrix.`preMultiply(T[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`	AbstractRealMatrix.`preMultiply(double[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`RealMatrix`	AbstractRealMatrix.`preMultiply(RealMatrix m)`	Returns the result of premultiplying `this` by `m`.
`RealVector`	AbstractRealMatrix.`preMultiply(RealVector v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`	Array2DRowFieldMatrix.`preMultiply(T[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`	Array2DRowRealMatrix.`preMultiply(double[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`	BlockFieldMatrix.`preMultiply(T[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`	BlockRealMatrix.`preMultiply(double[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`	DiagonalMatrix.`preMultiply(double[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`RealVector`	DiagonalMatrix.`preMultiply(RealVector v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`FieldMatrix<T>`	FieldMatrix.`preMultiply(FieldMatrix<T> m)`	Premultiply this matrix by `m`.
`FieldVector<T>`	FieldMatrix.`preMultiply(FieldVector<T> v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`	FieldMatrix.`preMultiply(T[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`	RealMatrix.`preMultiply(double[] v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`RealMatrix`	RealMatrix.`preMultiply(RealMatrix m)`	Returns the result of premultiplying `this` by `m`.
`RealVector`	RealMatrix.`preMultiply(RealVector v)`	Returns the (row) vector result of premultiplying this by the vector `v`.
`ArrayFieldVector<T>`	ArrayFieldVector.`projection(ArrayFieldVector<T> v)`	Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`	ArrayFieldVector.`projection(FieldVector<T> v)`	Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`	FieldVector.`projection(FieldVector<T> v)`	Find the orthogonal projection of this vector onto another vector.
`RealVector`	RealVector.`projection(RealVector v)`	Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`	SparseFieldVector.`projection(FieldVector<T> v)`	Find the orthogonal projection of this vector onto another vector.
`void`	ArrayFieldVector.`set(int index, ArrayFieldVector<T> v)`	Set a set of consecutive elements.
`void`	AbstractFieldMatrix.`setColumn(int column, T[] array)`	Set the entries in column number `column` as a column matrix.
`void`	AbstractRealMatrix.`setColumn(int column, double[] array)`	Sets the specified `column` of `this` matrix to the entries of the specified `array`.
`void`	BlockFieldMatrix.`setColumn(int column, T[] array)`	Set the entries in column number `column` as a column matrix.
`void`	BlockRealMatrix.`setColumn(int column, double[] array)`	Sets the specified `column` of `this` matrix to the entries of the specified `array`.
`void`	FieldMatrix.`setColumn(int column, T[] array)`	Set the entries in column number `column` as a column matrix.
`void`	RealMatrix.`setColumn(int column, double[] array)`	Sets the specified `column` of `this` matrix to the entries of the specified `array`.
`void`	AbstractFieldMatrix.`setColumnMatrix(int column, FieldMatrix<T> matrix)`	Set the entries in column number `column` as a column matrix.
`void`	AbstractRealMatrix.`setColumnMatrix(int column, RealMatrix matrix)`	Sets the specified `column` of `this` matrix to the entries of the specified column `matrix`.
`void`	BlockFieldMatrix.`setColumnMatrix(int column, FieldMatrix<T> matrix)`	Set the entries in column number `column` as a column matrix.
`void`	BlockRealMatrix.`setColumnMatrix(int column, RealMatrix matrix)`	Sets the specified `column` of `this` matrix to the entries of the specified column `matrix`.
`void`	FieldMatrix.`setColumnMatrix(int column, FieldMatrix<T> matrix)`	Set the entries in column number `column` as a column matrix.
`void`	RealMatrix.`setColumnMatrix(int column, RealMatrix matrix)`	Sets the specified `column` of `this` matrix to the entries of the specified column `matrix`.
`void`	AbstractFieldMatrix.`setColumnVector(int column, FieldVector<T> vector)`	Set the entries in column number `column` as a vector.
`void`	AbstractRealMatrix.`setColumnVector(int column, RealVector vector)`	Sets the specified `column` of `this` matrix to the entries of the specified `vector`.
`void`	BlockFieldMatrix.`setColumnVector(int column, FieldVector<T> vector)`	Set the entries in column number `column` as a vector.
`void`	BlockRealMatrix.`setColumnVector(int column, RealVector vector)`	Sets the specified `column` of `this` matrix to the entries of the specified `vector`.
`void`	FieldMatrix.`setColumnVector(int column, FieldVector<T> vector)`	Set the entries in column number `column` as a vector.
`void`	RealMatrix.`setColumnVector(int column, RealVector vector)`	Sets the specified `column` of `this` matrix to the entries of the specified `vector`.
`abstract void`	AbstractFieldMatrix.`setEntry(int row, int column, T value)`	Set the entry in the specified row and column.
`abstract void`	AbstractRealMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`void`	Array2DRowFieldMatrix.`setEntry(int row, int column, T value)`	Set the entry in the specified row and column.
`void`	Array2DRowRealMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`void`	ArrayRealVector.`setEntry(int index, double value)`	Set a single element.
`void`	BlockFieldMatrix.`setEntry(int row, int column, T value)`	Set the entry in the specified row and column.
`void`	BlockRealMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`void`	DiagonalMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`void`	FieldMatrix.`setEntry(int row, int column, T value)`	Set the entry in the specified row and column.
`void`	FieldVector.`setEntry(int index, T value)`	Set a single element.
`void`	OpenMapRealMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`void`	OpenMapRealVector.`setEntry(int index, double value)`	Set a single element.
`void`	RealMatrix.`setEntry(int row, int column, double value)`	Set the entry in the specified row and column.
`abstract void`	RealVector.`setEntry(int index, double value)`	Set a single element.
`void`	SparseFieldVector.`setEntry(int index, T value)`	Set a single element.
`void`	AbstractFieldMatrix.`setRow(int row, T[] array)`	Set the entries in row number `row` as a row matrix.
`void`	AbstractRealMatrix.`setRow(int row, double[] array)`	Sets the specified `row` of `this` matrix to the entries of the specified `array`.
`void`	Array2DRowFieldMatrix.`setRow(int row, T[] array)`	Set the entries in row number `row` as a row matrix.
`void`	Array2DRowRealMatrix.`setRow(int row, double[] array)`	Sets the specified `row` of `this` matrix to the entries of the specified `array`.
`void`	BlockFieldMatrix.`setRow(int row, T[] array)`	Set the entries in row number `row` as a row matrix.
`void`	BlockRealMatrix.`setRow(int row, double[] array)`	Sets the specified `row` of `this` matrix to the entries of the specified `array`.
`void`	FieldMatrix.`setRow(int row, T[] array)`	Set the entries in row number `row` as a row matrix.
`void`	RealMatrix.`setRow(int row, double[] array)`	Sets the specified `row` of `this` matrix to the entries of the specified `array`.
`void`	AbstractFieldMatrix.`setRowMatrix(int row, FieldMatrix<T> matrix)`	Set the entries in row number `row` as a row matrix.
`void`	AbstractRealMatrix.`setRowMatrix(int row, RealMatrix matrix)`	Sets the specified `row` of `this` matrix to the entries of the specified row `matrix`.
`void`	BlockFieldMatrix.`setRowMatrix(int row, BlockFieldMatrix<T> matrix)`	Sets the entries in row number `row` as a row matrix.
`void`	BlockFieldMatrix.`setRowMatrix(int row, FieldMatrix<T> matrix)`	Set the entries in row number `row` as a row matrix.
`void`	BlockRealMatrix.`setRowMatrix(int row, BlockRealMatrix matrix)`	Sets the entries in row number `row` as a row matrix.
`void`	BlockRealMatrix.`setRowMatrix(int row, RealMatrix matrix)`	Sets the specified `row` of `this` matrix to the entries of the specified row `matrix`.
`void`	FieldMatrix.`setRowMatrix(int row, FieldMatrix<T> matrix)`	Set the entries in row number `row` as a row matrix.
`void`	RealMatrix.`setRowMatrix(int row, RealMatrix matrix)`	Sets the specified `row` of `this` matrix to the entries of the specified row `matrix`.
`void`	AbstractFieldMatrix.`setRowVector(int row, FieldVector<T> vector)`	Set the entries in row number `row` as a vector.
`void`	AbstractRealMatrix.`setRowVector(int row, RealVector vector)`	Sets the specified `row` of `this` matrix to the entries of the specified `vector`.
`void`	BlockFieldMatrix.`setRowVector(int row, FieldVector<T> vector)`	Set the entries in row number `row` as a vector.
`void`	BlockRealMatrix.`setRowVector(int row, RealVector vector)`	Sets the specified `row` of `this` matrix to the entries of the specified `vector`.
`void`	FieldMatrix.`setRowVector(int row, FieldVector<T> vector)`	Set the entries in row number `row` as a vector.
`void`	RealMatrix.`setRowVector(int row, RealVector vector)`	Sets the specified `row` of `this` matrix to the entries of the specified `vector`.
`void`	AbstractFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)`	Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
`void`	AbstractRealMatrix.`setSubMatrix(double[][] subMatrix, int row, int column)`	Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void`	Array2DRowFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)`	Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
`void`	Array2DRowRealMatrix.`setSubMatrix(double[][] subMatrix, int row, int column)`	Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void`	BlockFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)`	Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
`void`	BlockRealMatrix.`setSubMatrix(double[][] subMatrix, int row, int column)`	Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void`	FieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)`	Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
`void`	RealMatrix.`setSubMatrix(double[][] subMatrix, int row, int column)`	Replace the submatrix starting at `row, column` using data in the input `subMatrix` array.
`void`	ArrayFieldVector.`setSubVector(int index, FieldVector<T> v)`	Set a set of consecutive elements.
`void`	ArrayRealVector.`setSubVector(int index, double[] v)`	Set a set of consecutive elements.
`void`	ArrayRealVector.`setSubVector(int index, RealVector v)`	Set a sequence of consecutive elements.
`void`	FieldVector.`setSubVector(int index, FieldVector<T> v)`	Set a set of consecutive elements.
`void`	OpenMapRealVector.`setSubVector(int index, RealVector v)`	Set a sequence of consecutive elements.
`abstract void`	RealVector.`setSubVector(int index, RealVector v)`	Set a sequence of consecutive elements.
`void`	SparseFieldVector.`setSubVector(int index, FieldVector<T> v)`	Set a set of consecutive elements.
`RealMatrix`	DecompositionSolver.`solve(RealMatrix b)`	Solve the linear equation A × X = B for matrices A.
`RealVector`	DecompositionSolver.`solve(RealVector b)`	Solve the linear equation A × X = B for matrices A.
`RealVector`	IterativeLinearSolver.`solve(RealLinearOperator a, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	IterativeLinearSolver.`solve(RealLinearOperator a, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, boolean goodb, double shift)`	Returns an estimate of the solution to the linear system (A - shift · I) · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealVector b)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealVector b, boolean goodb, double shift)`	Returns the solution to the system (A - shift · I) · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solve(RealLinearOperator a, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	ConjugateGradient.`solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`abstract RealVector`	IterativeLinearSolver.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`abstract RealVector`	PreconditionedIterativeLinearSolver.`solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	PreconditionedIterativeLinearSolver.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x0)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x, boolean goodb, double shift)`	Returns an estimate of the solution to the linear system (A - shift · I) · x = b.
`RealVector`	SymmLQ.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`RealVector`	SymmLQ.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x)`	Returns an estimate of the solution to the linear system A · x = b.
`static void`	MatrixUtils.`solveLowerTriangularSystem(RealMatrix rm, RealVector b)`	Solve a system of composed of a Lower Triangular Matrix `RealMatrix`.
`static void`	MatrixUtils.`solveUpperTriangularSystem(RealMatrix rm, RealVector b)`	Solver a system composed of an Upper Triangular Matrix `RealMatrix`.
`FieldMatrix<T>`	AbstractFieldMatrix.`subtract(FieldMatrix<T> m)`	Subtract `m` from this matrix.
`RealMatrix`	AbstractRealMatrix.`subtract(RealMatrix m)`	Returns `this` minus `m`.
`Array2DRowFieldMatrix<T>`	Array2DRowFieldMatrix.`subtract(Array2DRowFieldMatrix<T> m)`	Subtract `m` from this matrix.
`Array2DRowRealMatrix`	Array2DRowRealMatrix.`subtract(Array2DRowRealMatrix m)`	Returns `this` minus `m`.
`ArrayFieldVector<T>`	ArrayFieldVector.`subtract(ArrayFieldVector<T> v)`	Compute `this` minus `v`.
`FieldVector<T>`	ArrayFieldVector.`subtract(FieldVector<T> v)`	Compute `this` minus `v`.
`ArrayRealVector`	ArrayRealVector.`subtract(RealVector v)`	Subtract `v` from this vector.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`subtract(BlockFieldMatrix<T> m)`	Compute `this - m`.
`FieldMatrix<T>`	BlockFieldMatrix.`subtract(FieldMatrix<T> m)`	Subtract `m` from this matrix.
`BlockRealMatrix`	BlockRealMatrix.`subtract(BlockRealMatrix m)`	Subtract `m` from this matrix.
`BlockRealMatrix`	BlockRealMatrix.`subtract(RealMatrix m)`	Returns `this` minus `m`.
`DiagonalMatrix`	DiagonalMatrix.`subtract(DiagonalMatrix m)`	Returns `this` minus `m`.
`FieldMatrix<T>`	FieldMatrix.`subtract(FieldMatrix<T> m)`	Subtract `m` from this matrix.
`FieldVector<T>`	FieldVector.`subtract(FieldVector<T> v)`	Compute `this` minus `v`.
`OpenMapRealMatrix`	OpenMapRealMatrix.`subtract(OpenMapRealMatrix m)`	Subtract `m` from this matrix.
`OpenMapRealMatrix`	OpenMapRealMatrix.`subtract(RealMatrix m)`	Returns `this` minus `m`.
`OpenMapRealVector`	OpenMapRealVector.`subtract(OpenMapRealVector v)`	Optimized method to subtract OpenMapRealVectors.
`RealVector`	OpenMapRealVector.`subtract(RealVector v)`	Subtract `v` from this vector.
`RealMatrix`	RealMatrix.`subtract(RealMatrix m)`	Returns `this` minus `m`.
`RealVector`	RealVector.`subtract(RealVector v)`	Subtract `v` from this vector.
`FieldVector<T>`	SparseFieldVector.`subtract(FieldVector<T> v)`	Compute `this` minus `v`.
`SparseFieldVector<T>`	SparseFieldVector.`subtract(SparseFieldVector<T> v)`	Optimized method to compute `this` minus `v`.
`static <T extends FieldElement<T>> T[][]`	BlockFieldMatrix.`toBlocksLayout(T[][] rawData)`	Convert a data array from raw layout to blocks layout.
`static double[][]`	BlockRealMatrix.`toBlocksLayout(double[][] rawData)`	Convert a data array from raw layout to blocks layout.
`FieldMatrix<T>`	Array2DRowFieldMatrix.`transposeMultiply(Array2DRowFieldMatrix<T> m)`	Returns the result of postmultiplying `this^T` by `m`.
`RealMatrix`	Array2DRowRealMatrix.`transposeMultiply(Array2DRowRealMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`transposeMultiply(BlockFieldMatrix<T> m)`	Returns the result of postmultiplying `this^T` by `m`.
`BlockFieldMatrix<T>`	BlockFieldMatrix.`transposeMultiply(FieldMatrix<T> m)`	Returns the result of postmultiplying `this^T` by `m`.
`BlockRealMatrix`	BlockRealMatrix.`transposeMultiply(BlockRealMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`BlockRealMatrix`	BlockRealMatrix.`transposeMultiply(RealMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`DiagonalMatrix`	DiagonalMatrix.`transposeMultiply(DiagonalMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`default FieldMatrix<T>`	FieldMatrix.`transposeMultiply(FieldMatrix<T> m)`	Returns the result of postmultiplying `this^T` by `m`.
`RealMatrix`	OpenMapRealMatrix.`transposeMultiply(RealMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`default RealMatrix`	RealMatrix.`transposeMultiply(RealMatrix m)`	Returns the result of postmultiplying `this^T` by `m`.
`FieldMatrix<T>`	SparseFieldMatrix.`transposeMultiply(FieldMatrix<T> m)`	Returns the result of postmultiplying `this^T` by `m`.
`T`	AbstractFieldMatrix.`walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`T`	AbstractFieldMatrix.`walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`double`	AbstractRealMatrix.`walkInColumnOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`double`	AbstractRealMatrix.`walkInColumnOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`T`	Array2DRowFieldMatrix.`walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`T`	Array2DRowFieldMatrix.`walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`double`	Array2DRowRealMatrix.`walkInColumnOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`double`	Array2DRowRealMatrix.`walkInColumnOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`T`	FieldMatrix.`walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`T`	FieldMatrix.`walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`double`	RealMatrix.`walkInColumnOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in column order.
`double`	RealMatrix.`walkInColumnOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in column order.
`T`	ArrayFieldVector.`walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`	Visits (and possibly alters) some entries of this vector in default order (increasing index).
`T`	ArrayFieldVector.`walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in default order (increasing index).
`double`	ArrayRealVector.`walkInDefaultOrder(RealVectorChangingVisitor visitor, int start, int end)`	Visits (and possibly alters) some entries of this vector in default order (increasing index).
`double`	ArrayRealVector.`walkInDefaultOrder(RealVectorPreservingVisitor visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in default order (increasing index).
`double`	RealVector.`walkInDefaultOrder(RealVectorChangingVisitor visitor, int start, int end)`	Visits (and possibly alters) some entries of this vector in default order (increasing index).
`double`	RealVector.`walkInDefaultOrder(RealVectorPreservingVisitor visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in default order (increasing index).
`T`	SparseFieldVector.`walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`	Visits (and possibly alters) some entries of this vector in default order (increasing index).
`T`	SparseFieldVector.`walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in default order (increasing index).
`T`	AbstractFieldMatrix.`walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`T`	AbstractFieldMatrix.`walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`double`	AbstractRealMatrix.`walkInOptimizedOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`double`	AbstractRealMatrix.`walkInOptimizedOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`T`	ArrayFieldVector.`walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`	Visits (and possibly change) some entries of this vector in optimized order.
`T`	ArrayFieldVector.`walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in optimized order.
`double`	ArrayRealVector.`walkInOptimizedOrder(RealVectorChangingVisitor visitor, int start, int end)`	Visits (and possibly change) some entries of this vector in optimized order.
`double`	ArrayRealVector.`walkInOptimizedOrder(RealVectorPreservingVisitor visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in optimized order.
`T`	BlockFieldMatrix.`walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`T`	BlockFieldMatrix.`walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`double`	BlockRealMatrix.`walkInOptimizedOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`double`	BlockRealMatrix.`walkInOptimizedOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`T`	FieldMatrix.`walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`T`	FieldMatrix.`walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`double`	RealMatrix.`walkInOptimizedOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries using the fastest possible order.
`double`	RealMatrix.`walkInOptimizedOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries using the fastest possible order.
`double`	RealVector.`walkInOptimizedOrder(RealVectorChangingVisitor visitor, int start, int end)`	Visits (and possibly change) some entries of this vector in optimized order.
`double`	RealVector.`walkInOptimizedOrder(RealVectorPreservingVisitor visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in optimized order.
`T`	SparseFieldVector.`walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor, int start, int end)`	Visits (and possibly change) some entries of this vector in optimized order.
`T`	SparseFieldVector.`walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor, int start, int end)`	Visits (but does not alter) some entries of this vector in optimized order.
`T`	AbstractFieldMatrix.`walkInRowOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`T`	AbstractFieldMatrix.`walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`double`	AbstractRealMatrix.`walkInRowOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`double`	AbstractRealMatrix.`walkInRowOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`T`	Array2DRowFieldMatrix.`walkInRowOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`T`	Array2DRowFieldMatrix.`walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`double`	Array2DRowRealMatrix.`walkInRowOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`double`	Array2DRowRealMatrix.`walkInRowOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`T`	BlockFieldMatrix.`walkInRowOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`T`	BlockFieldMatrix.`walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`double`	BlockRealMatrix.`walkInRowOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`double`	BlockRealMatrix.`walkInRowOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`T`	FieldMatrix.`walkInRowOrder(FieldMatrixChangingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`T`	FieldMatrix.`walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.
`double`	RealMatrix.`walkInRowOrder(RealMatrixChangingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (and possibly change) some matrix entries in row order.
`double`	RealMatrix.`walkInRowOrder(RealMatrixPreservingVisitor visitor, int startRow, int endRow, int startColumn, int endColumn)`	Visit (but don't change) some matrix entries in row order.

Constructors in org.hipparchus.linear that throw MathIllegalArgumentException
Constructor	Description
`AbstractFieldMatrix(Field<T> field, int rowDimension, int columnDimension)`	Create a new FieldMatrix with the supplied row and column dimensions.
`AbstractRealMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix with the supplied row and column dimensions.
`Array2DRowFieldMatrix(Field<T> field, int rowDimension, int columnDimension)`	Create a new `FieldMatrix<T>` with the supplied row and column dimensions.
`Array2DRowFieldMatrix(Field<T> field, T[][] d)`	Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(Field<T> field, T[][] d, boolean copyArray)`	Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(T[] v)`	Create a new (column) `FieldMatrix<T>` using `v` as the data for the unique column of the created matrix.
`Array2DRowFieldMatrix(T[][] d)`	Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(T[][] d, boolean copyArray)`	Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowRealMatrix(double[][] d)`	Create a new `RealMatrix` using the input array as the underlying data array.
`Array2DRowRealMatrix(double[][] d, boolean copyArray)`	Create a new RealMatrix using the input array as the underlying data array.
`Array2DRowRealMatrix(int rowDimension, int columnDimension)`	Create a new RealMatrix with the supplied row and column dimensions.
`ArrayFieldVector(Field<T> field, T[] d, int pos, int size)`	Construct a vector from part of a array.
`ArrayFieldVector(Field<T> field, T[] v1, T[] v2)`	Construct a vector by appending one vector to another vector.
`ArrayFieldVector(T[] d)`	Construct a vector from an array, copying the input array.
`ArrayFieldVector(T[] d, boolean copyArray)`	Create a new ArrayFieldVector using the input array as the underlying data array.
`ArrayFieldVector(T[] d, int pos, int size)`	Construct a vector from part of a array.
`ArrayFieldVector(T[] v1, T[] v2)`	Construct a vector by appending one vector to another vector.
`ArrayRealVector(double[] d, int pos, int size)`	Construct a vector from part of a array.
`ArrayRealVector(Double[] d, int pos, int size)`	Construct a vector from part of an array.
`BlockFieldMatrix(int rows, int columns, T[][] blockData, boolean copyArray)`	Create a new dense matrix copying entries from block layout data.
`BlockFieldMatrix(Field<T> field, int rows, int columns)`	Create a new matrix with the supplied row and column dimensions.
`BlockFieldMatrix(T[][] rawData)`	Create a new dense matrix copying entries from raw layout data.
`BlockRealMatrix(double[][] rawData)`	Create a new dense matrix copying entries from raw layout data.
`BlockRealMatrix(int rows, int columns)`	Create a new matrix with the supplied row and column dimensions.
`BlockRealMatrix(int rows, int columns, double[][] blockData, boolean copyArray)`	Create a new dense matrix copying entries from block layout data.
`DiagonalMatrix(int dimension)`	Creates a matrix with the supplied dimension.
`OpenMapRealMatrix(int rowDimension, int columnDimension)`	Build a sparse matrix with the supplied row and column dimensions.
`RectangularCholeskyDecomposition(RealMatrix matrix)`	Decompose a symmetric positive semidefinite matrix.
`RectangularCholeskyDecomposition(RealMatrix matrix, double small)`	Decompose a symmetric positive semidefinite matrix.

Uses of MathIllegalArgumentException in org.hipparchus.migration.exception

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.exception
Modifier and Type	Class	Description
`class`	`DimensionMismatchException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`InsufficientDataException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`MathIllegalNumberException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`MultiDimensionMismatchException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NoBracketingException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NoDataException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonMonotonicSequenceException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NotANumberException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NotFiniteNumberException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NotPositiveException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NotStrictlyPositiveException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NumberIsTooLargeException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NumberIsTooSmallException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`OutOfRangeException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`ZeroException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`

Uses of MathIllegalArgumentException in org.hipparchus.migration.genetics

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.genetics
Modifier and Type	Class	Description
`class`	`InvalidRepresentationException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalStateException`

Uses of MathIllegalArgumentException in org.hipparchus.migration.geometry.euclidean.threed

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.geometry.euclidean.threed
Modifier and Type	Class	Description
`class`	`NotARotationMatrixException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalStateException`

Uses of MathIllegalArgumentException in org.hipparchus.migration.linear

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.linear
Modifier and Type	Class	Description
`class`	`IllConditionedOperatorException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`MatrixDimensionMismatchException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonPositiveDefiniteMatrixException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonPositiveDefiniteOperatorException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonSelfAdjointOperatorException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonSquareMatrixException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonSquareOperatorException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`NonSymmetricMatrixException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`
`class`	`SingularMatrixException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalStateException`
`class`	`SingularOperatorException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`

Uses of MathIllegalArgumentException in org.hipparchus.migration.ode

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.ode
Modifier and Type	Class	Description
`static class`	`JacobianMatrices.MismatchedEquations`	Deprecated. Special exception for equations mismatch.
`class`	`UnknownParameterException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`

Methods in org.hipparchus.migration.ode that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	FirstOrderDifferentialEquations.`computeDerivatives(double t, double[] y, double[] yDot)`	Deprecated. Get the current time derivative of the state vector.
`default double[]`	SecondaryEquations.`computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary)`	Deprecated. Compute the derivatives related to the secondary state parameters.
`void`	SecondaryEquations.`computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary, double[] secondaryDot)`	Deprecated. Compute the derivatives related to the secondary state parameters.
`double[][]`	MainStateJacobianProvider.`computeMainStateJacobian(double t, double[] y, double[] yDot)`	Deprecated. Compute the jacobian matrix of ODE with respect to main state.
`default double[]`	ParameterJacobianProvider.`computeParameterJacobian(double t, double[] y, double[] yDot, String paramName)`	Deprecated. Compute the Jacobian matrix of ODE with respect to one parameter.
`void`	ParameterJacobianProvider.`computeParameterJacobian(double t, double[] y, double[] yDot, String paramName, double[] dFdP)`	Deprecated. Compute the Jacobian matrix of ODE with respect to one parameter.
`void`	JacobianMatrices.`registerVariationalEquations(ExpandableODE expandable)`	Deprecated. Register the variational equations for the Jacobians matrices to the expandable set.
`void`	JacobianMatrices.`setInitialMainStateJacobian(double[][] dYdY0)`	Deprecated. Set the initial value of the Jacobian matrix with respect to state.
`void`	JacobianMatrices.`setInitialParameterJacobian(String pName, double[] dYdP)`	Deprecated. Set the initial value of a column of the Jacobian matrix with respect to one parameter.
`void`	JacobianMatrices.`setParameterStep(String parameter, double hP)`	Deprecated. Set the step associated to a parameter in order to compute by finite difference the Jacobian matrix.

Constructors in org.hipparchus.migration.ode that throw MathIllegalArgumentException
Constructor	Description
`JacobianMatrices(OrdinaryDifferentialEquation fode, double[] hY, String... parameters)`	Deprecated. Simple constructor for a secondary equations set computing Jacobian matrices.

Uses of MathIllegalArgumentException in org.hipparchus.migration.stat.regression

Subclasses of MathIllegalArgumentException in org.hipparchus.migration.stat.regression
Modifier and Type	Class	Description
`class`	`ModelSpecificationException`	Deprecated. as of 1.0, this exception is replaced by `MathIllegalArgumentException`

Uses of MathIllegalArgumentException in org.hipparchus.ode

Subclasses of MathIllegalArgumentException in org.hipparchus.ode
Modifier and Type	Class	Description
`static class`	`VariationalEquation.MismatchedEquations`	Special exception for equations mismatch.

Methods in org.hipparchus.ode that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected FieldODEStateAndDerivative<T>`	AbstractFieldIntegrator.`acceptStep(AbstractFieldODEStateInterpolator<T> interpolator, T tEnd)`	Accept a step, triggering events and step handlers.
`protected ODEStateAndDerivative`	AbstractIntegrator.`acceptStep(AbstractODEStateInterpolator interpolator, double tEnd)`	Accept a step, triggering events and step handlers.
`void`	DenseOutputModel.`append(DenseOutputModel model)`	Append another model at the end of the instance.
`void`	FieldDenseOutputModel.`append(FieldDenseOutputModel<T> model)`	Append another model at the end of the instance.
`void`	AbstractParameterizable.`complainIfNotSupported(String name)`	Check if a parameter is supported and throw an IllegalArgumentException if not.
`T[]`	AbstractFieldIntegrator.`computeDerivatives(T t, T[] y)`	Compute the derivatives and check the number of evaluations.
`double[]`	AbstractIntegrator.`computeDerivatives(double t, double[] y)`	Compute the derivatives and check the number of evaluations.
`Complex[]`	ComplexSecondaryODE.`computeDerivatives(double t, Complex[] primary, Complex[] primaryDot, Complex[] secondary)`	Compute the derivatives related to the secondary state parameters.
`double[]`	ExpandableODE.`computeDerivatives(double t, double[] y)`	Get the current time derivative of the complete state vector.
`T[]`	FieldExpandableODE.`computeDerivatives(T t, T[] y)`	Get the current time derivative of the complete state vector.
`T[]`	FieldSecondaryODE.`computeDerivatives(T t, T[] primary, T[] primaryDot, T[] secondary)`	Compute the derivatives related to the secondary state parameters.
`double[]`	SecondaryODE.`computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary)`	Compute the derivatives related to the secondary state parameters.
`double[][]`	ODEJacobiansProvider.`computeMainStateJacobian(double t, double[] y, double[] yDot)`	Compute the Jacobian matrix of ODE with respect to state.
`double[]`	NamedParameterJacobianProvider.`computeParameterJacobian(double t, double[] y, double[] yDot, String paramName)`	Compute the Jacobian matrix of ODE with respect to one parameter.
`default double[]`	ODEJacobiansProvider.`computeParameterJacobian(double t, double[] y, double[] yDot, String paramName)`	Compute the Jacobian matrix of ODE with respect to one parameter.
`double[]`	EquationsMapper.`extractEquationData(int index, double[] complete)`	Extract equation data from a complete state or derivative array.
`T[]`	FieldEquationsMapper.`extractEquationData(int index, T[] complete)`	Extract equation data from a complete state or derivative array.
`double`	ParametersController.`getParameter(String name)`	Get parameter value from its name.
`void`	EquationsMapper.`insertEquationData(int index, double[] equationData, double[] complete)`	Insert equation data into a complete state or derivative array.
`void`	FieldEquationsMapper.`insertEquationData(int index, T[] equationData, T[] complete)`	Insert equation data into a complete state or derivative array.
`FieldODEStateAndDerivative<T>`	FieldODEIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	ODEIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`default double`	ODEIntegrator.`integrate(OrdinaryDifferentialEquation equations, double t0, double[] y0, double t, double[] y)`	Deprecated. as of 1.0, replaced with `ODEIntegrator.integrate(ExpandableODE, ODEState, double)`
`default ODEStateAndDerivative`	ODEIntegrator.`integrate(OrdinaryDifferentialEquation equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	EquationsMapper.`mapStateAndDerivative(double t, double[] y, double[] yDot)`	Map flat arrays to a state and derivative.
`FieldODEStateAndDerivative<T>`	FieldEquationsMapper.`mapStateAndDerivative(T t, T[] y, T[] yDot)`	Map flat arrays to a state and derivative.
`protected void`	AbstractFieldIntegrator.`sanityChecks(FieldODEState<T> initialState, T t)`	Check the integration span.
`protected void`	AbstractIntegrator.`sanityChecks(ODEState initialState, double t)`	Check the integration span.
`void`	VariationalEquation.`setInitialMainStateJacobian(double[][] dYdY0)`	Set the initial value of the Jacobian matrix with respect to state.
`void`	VariationalEquation.`setInitialParameterJacobian(String pName, double[] dYdP)`	Set the initial value of a column of the Jacobian matrix with respect to one parameter.
`void`	ParametersController.`setParameter(String name, double value)`	Set the value for a given parameter.
`protected void`	MultistepFieldIntegrator.`start(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T t)`	Start the integration.
`protected void`	MultistepIntegrator.`start(ExpandableODE equations, ODEState initialState, double finalTime)`	Start the integration.

Constructors in org.hipparchus.ode that throw MathIllegalArgumentException
Constructor	Description
`MultistepFieldIntegrator(Field<T> field, String name, int nSteps, int order, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build a multistep integrator with the given stepsize bounds.
`MultistepIntegrator(String name, int nSteps, int order, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build a multistep integrator with the given stepsize bounds.

Uses of MathIllegalArgumentException in org.hipparchus.ode.events

Methods in org.hipparchus.ode.events that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`boolean`	EventState.`evaluateStep(ODEStateInterpolator interpolator)`	Evaluate the impact of the proposed step on the event handler.
`boolean`	FieldEventState.`evaluateStep(FieldODEStateInterpolator<T> interpolator)`	Evaluate the impact of the proposed step on the event handler.

Uses of MathIllegalArgumentException in org.hipparchus.ode.nonstiff

Methods in org.hipparchus.ode.nonstiff that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`protected T`	AdaptiveStepsizeFieldIntegrator.`filterStep(T h, boolean forward, boolean acceptSmall)`	Filter the integration step.
`protected double`	AdaptiveStepsizeIntegrator.`filterStep(double h, boolean forward, boolean acceptSmall)`	Filter the integration step.
`T`	AdaptiveStepsizeFieldIntegrator.`initializeStep(boolean forward, int order, T[] scale, FieldODEStateAndDerivative<T> state0, FieldEquationsMapper<T> mapper)`	Initialize the integration step.
`double`	AdaptiveStepsizeIntegrator.`initializeStep(boolean forward, int order, double[] scale, ODEStateAndDerivative state0, EquationsMapper mapper)`	Initialize the integration step.
`FieldODEStateAndDerivative<T>`	AdamsBashforthFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	AdamsBashforthIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`abstract FieldODEStateAndDerivative<T>`	AdamsFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`abstract ODEStateAndDerivative`	AdamsIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`FieldODEStateAndDerivative<T>`	AdamsMoultonFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	AdamsMoultonIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`FieldODEStateAndDerivative<T>`	EmbeddedRungeKuttaFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	EmbeddedRungeKuttaIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	GraggBulirschStoerIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`FieldODEStateAndDerivative<T>`	RungeKuttaFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`	Integrate the differential equations up to the given time.
`ODEStateAndDerivative`	RungeKuttaIntegrator.`integrate(ExpandableODE equations, ODEState initialState, double finalTime)`	Integrate the differential equations up to the given time.
`protected void`	AdaptiveStepsizeFieldIntegrator.`sanityChecks(FieldODEState<T> initialState, T t)`	Check the integration span.
`protected void`	AdaptiveStepsizeIntegrator.`sanityChecks(ODEState initialState, double t)`	Check the integration span.

Constructors in org.hipparchus.ode.nonstiff that throw MathIllegalArgumentException
Constructor	Description
`AdamsBashforthFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams-Bashforth integrator with the given order and step control parameters.
`AdamsBashforthIntegrator(int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams-Bashforth integrator with the given order and step control parameters.
`AdamsFieldIntegrator(Field<T> field, String name, int nSteps, int order, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams integrator with the given order and step control parameters.
`AdamsIntegrator(String name, int nSteps, int order, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams integrator with the given order and step control parameters.
`AdamsMoultonFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams-Moulton integrator with the given order and error control parameters.
`AdamsMoultonIntegrator(int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance)`	Build an Adams-Moulton integrator with the given order and error control parameters.

Uses of MathIllegalArgumentException in org.hipparchus.optim.nonlinear.scalar

Constructors in org.hipparchus.optim.nonlinear.scalar that throw MathIllegalArgumentException
Constructor	Description
`MultiStartMultivariateOptimizer(MultivariateOptimizer optimizer, int starts, RandomVectorGenerator generator)`	Create a multi-start optimizer from a single-start optimizer.

Uses of MathIllegalArgumentException in org.hipparchus.optim.nonlinear.scalar.noderiv

Methods in org.hipparchus.optim.nonlinear.scalar.noderiv that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`PointValuePair`	CMAESOptimizer.`optimize(OptimizationData... optData)`	Stores data and performs the optimization.

Constructors in org.hipparchus.optim.nonlinear.scalar.noderiv that throw MathIllegalArgumentException
Constructor	Description
`PopulationSize(int size)`
`Sigma(double[] s)`

Uses of MathIllegalArgumentException in org.hipparchus.random

Methods in org.hipparchus.random that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`String`	RandomDataGenerator.`nextHexString(int len)`	Generates a random string of hex characters of length `len`.
`long`	RandomDataGenerator.`nextLong(long lower, long upper)`	Returns a uniformly distributed random long integer between lower and upper (inclusive).
`int[]`	RandomDataGenerator.`nextPermutation(int n, int k)`	Generates an integer array of length `k` whose entries are selected randomly, without repetition, from the integers `0, ..., n - 1` (inclusive).
`double[]`	RandomDataGenerator.`nextSample(double[] a, int k)`	Returns an array of `k` double values selected randomly from the double array `a`.
`Object[]`	RandomDataGenerator.`nextSample(Collection<?> c, int k)`	Returns an array of `k` objects selected randomly from the Collection `c`.
`double[]`	HaltonSequenceGenerator.`skipTo(int index)`	Skip to the i-th point in the Halton sequence.
`double[]`	SobolSequenceGenerator.`skipTo(int index)`	Skip to the i-th point in the Sobol sequence.

Constructors in org.hipparchus.random that throw MathIllegalArgumentException
Constructor	Description
`HaltonSequenceGenerator(int dimension)`	Construct a new Halton sequence generator for the given space dimension.
`HaltonSequenceGenerator(int dimension, int[] bases, int[] weights)`	Construct a new Halton sequence generator with the given base numbers and weights for each dimension.
`SobolSequenceGenerator(int dimension)`	Construct a new Sobol sequence generator for the given space dimension.
`SobolSequenceGenerator(int dimension, InputStream is)`	Construct a new Sobol sequence generator for the given space dimension with direction vectors loaded from the given stream.
`StableRandomGenerator(RandomGenerator generator, double alpha, double beta)`	Create a new generator.

Uses of MathIllegalArgumentException in org.hipparchus.special

Methods in org.hipparchus.special that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static double`	Gamma.`logGamma1p(double x)`	Returns the value of log Γ(1 + x) for -0.5 ≤ x ≤ 1.5.
`double`	BesselJ.`value(double x)`	Returns the value of the constructed Bessel function of the first kind, for the passed argument.
`static double`	BesselJ.`value(double order, double x)`	Returns the first Bessel function, \(J_{order}(x)\).

Uses of MathIllegalArgumentException in org.hipparchus.stat

Methods in org.hipparchus.stat that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static double`	StatUtils.`geometricMean(double... values)`	Returns the geometric mean of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`geometricMean(double[] values, int begin, int length)`	Returns the geometric mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`max(double... values)`	Returns the maximum of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`max(double[] values, int begin, int length)`	Returns the maximum of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`mean(double... values)`	Returns the arithmetic mean of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`mean(double[] values, int begin, int length)`	Returns the arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`meanDifference(double[] sample1, double[] sample2)`	Returns the mean of the (signed) differences between corresponding elements of the input arrays -- i.e., sum(sample1[i] - sample2[i]) / sample1.length.
`static double`	StatUtils.`min(double... values)`	Returns the minimum of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`min(double[] values, int begin, int length)`	Returns the minimum of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double[]`	StatUtils.`mode(double... sample)`	Returns the sample mode(s).
`static double`	StatUtils.`percentile(double[] values, double p)`	Returns an estimate of the `p`th percentile of the values in the `values` array.
`static double`	StatUtils.`percentile(double[] values, int begin, int length, double p)`	Returns an estimate of the `p`th percentile of the values in the `values` array, starting with the element in (0-based) position `begin` in the array and including `length` values.
`static double`	StatUtils.`populationVariance(double... values)`	Returns the population variance of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`populationVariance(double[] values, double mean)`	Returns the population variance of the entries in the input array, using the precomputed mean value.
`static double`	StatUtils.`populationVariance(double[] values, double mean, int begin, int length)`	Returns the population variance of the entries in the specified portion of the input array, using the precomputed mean value.
`static double`	StatUtils.`populationVariance(double[] values, int begin, int length)`	Returns the population variance of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`product(double... values)`	Returns the product of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`product(double[] values, int begin, int length)`	Returns the product of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`sum(double... values)`	Returns the sum of the values in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`sum(double[] values, int begin, int length)`	Returns the sum of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`sumDifference(double[] sample1, double[] sample2)`	Returns the sum of the (signed) differences between corresponding elements of the input arrays -- i.e., sum(sample1[i] - sample2[i]).
`static double`	StatUtils.`sumLog(double... values)`	Returns the sum of the natural logs of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`sumLog(double[] values, int begin, int length)`	Returns the sum of the natural logs of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`sumSq(double... values)`	Returns the sum of the squares of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`sumSq(double[] values, int begin, int length)`	Returns the sum of the squares of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`variance(double... values)`	Returns the variance of the entries in the input array, or `Double.NaN` if the array is empty.
`static double`	StatUtils.`variance(double[] values, double mean)`	Returns the variance of the entries in the input array, using the precomputed mean value.
`static double`	StatUtils.`variance(double[] values, double mean, int begin, int length)`	Returns the variance of the entries in the specified portion of the input array, using the precomputed mean value.
`static double`	StatUtils.`variance(double[] values, int begin, int length)`	Returns the variance of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`static double`	StatUtils.`varianceDifference(double[] sample1, double[] sample2, double meanDifference)`	Returns the variance of the (signed) differences between corresponding elements of the input arrays -- i.e., var(sample1[i] - sample2[i]).

Uses of MathIllegalArgumentException in org.hipparchus.stat.correlation

Methods in org.hipparchus.stat.correlation that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	StorelessCovariance.`append(StorelessCovariance sc)`	Appends `sc` to this, effectively aggregating the computations in `sc` with this.
`protected RealMatrix`	Covariance.`computeCovarianceMatrix(double[][] data)`	Create a covariance matrix from a rectangular array whose columns represent covariates.
`protected RealMatrix`	Covariance.`computeCovarianceMatrix(double[][] data, boolean biasCorrected)`	Compute a covariance matrix from a rectangular array whose columns represent covariates.
`protected RealMatrix`	Covariance.`computeCovarianceMatrix(RealMatrix matrix)`	Create a covariance matrix from a matrix whose columns represent covariates.
`protected RealMatrix`	Covariance.`computeCovarianceMatrix(RealMatrix matrix, boolean biasCorrected)`	Compute a covariance matrix from a matrix whose columns represent covariates.
`double`	KendallsCorrelation.`correlation(double[] xArray, double[] yArray)`	Computes the Kendall's Tau rank correlation coefficient between the two arrays.
`double`	Covariance.`covariance(double[] xArray, double[] yArray)`	Computes the covariance between the two arrays, using the bias-corrected formula.
`double`	Covariance.`covariance(double[] xArray, double[] yArray, boolean biasCorrected)`	Computes the covariance between the two arrays.
`double`	StorelessCovariance.`getCovariance(int xIndex, int yIndex)`	Get the covariance for an individual element of the covariance matrix.
`RealMatrix`	StorelessCovariance.`getCovarianceMatrix()`	Returns the covariance matrix
`double[][]`	StorelessCovariance.`getData()`	Return the covariance matrix as two-dimensional array.
`void`	StorelessCovariance.`increment(double[] data)`	Increment the covariance matrix with one row of data.

Constructors in org.hipparchus.stat.correlation that throw MathIllegalArgumentException
Constructor	Description
`Covariance(double[][] data)`	Create a Covariance matrix from a rectangular array whose columns represent covariates.
`Covariance(double[][] data, boolean biasCorrected)`	Create a Covariance matrix from a rectangular array whose columns represent covariates.
`Covariance(RealMatrix matrix)`	Create a covariance matrix from a matrix whose columns represent covariates.
`Covariance(RealMatrix matrix, boolean biasCorrected)`	Create a covariance matrix from a matrix whose columns represent covariates.
`SpearmansCorrelation(RealMatrix dataMatrix, RankingAlgorithm rankingAlgorithm)`	Create a SpearmansCorrelation with the given input data matrix and ranking algorithm.
`SpearmansCorrelation(RankingAlgorithm rankingAlgorithm)`	Create a SpearmansCorrelation with the given ranking algorithm.

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive

Methods in org.hipparchus.stat.descriptive that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	MultivariateSummaryStatistics.`addValue(double[] value)`	Add an n-tuple to the data
`double`	AbstractUnivariateStatistic.`evaluate()`	Returns the result of evaluating the statistic over the stored data.
`abstract double`	AbstractUnivariateStatistic.`evaluate(double[] values, int begin, int length)`	Returns the result of evaluating the statistic over the specified entries in the input array.
`default double`	StorelessUnivariateStatistic.`evaluate(double[] values, int begin, int length)`	Returns the result of evaluating the statistic over the specified entries in the input array.
`default double`	UnivariateStatistic.`evaluate(double[] values)`	Returns the result of evaluating the statistic over the input array.
`double`	UnivariateStatistic.`evaluate(double[] values, int begin, int length)`	Returns the result of evaluating the statistic over the specified entries in the input array.
`default double`	WeightedEvaluation.`evaluate(double[] values, double[] weights)`	Returns the result of evaluating the statistic over the input array, using the supplied weights.
`double`	WeightedEvaluation.`evaluate(double[] values, double[] weights, int begin, int length)`	Returns the result of evaluating the statistic over the specified entries in the input array, using corresponding entries in the supplied weights array.
`double`	DescriptiveStatistics.`getPercentile(double p)`	Returns an estimate for the pth percentile of the stored values.
`default void`	StorelessUnivariateStatistic.`incrementAll(double[] values)`	Updates the internal state of the statistic to reflect addition of all values in the values array.
`default void`	StorelessUnivariateStatistic.`incrementAll(double[] values, int start, int length)`	Updates the internal state of the statistic to reflect addition of the values in the designated portion of the values array.
`void`	AbstractUnivariateStatistic.`setData(double[] values, int begin, int length)`	Set the data array.
`void`	DescriptiveStatistics.`setWindowSize(int windowSize)`	WindowSize controls the number of values that contribute to the reported statistics.

Constructors in org.hipparchus.stat.descriptive that throw MathIllegalArgumentException
Constructor	Description
`DescriptiveStatistics(int size)`	Construct a DescriptiveStatistics instance with the specified window.

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.moment

Methods in org.hipparchus.stat.descriptive.moment that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	GeometricMean.`evaluate(double[] values, int begin, int length)`	Returns the geometric mean of the entries in the specified portion of the input array.
`double`	Kurtosis.`evaluate(double[] values, int begin, int length)`	Returns the kurtosis of the entries in the specified portion of the input array.
`double`	Mean.`evaluate(double[] values, double[] weights, int begin, int length)`	Returns the weighted arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Mean.`evaluate(double[] values, int begin, int length)`	Returns the arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	SemiVariance.`evaluate(double[] values, double cutoff)`	Returns the `SemiVariance` of the designated values against the cutoff, using instance properties variancDirection and biasCorrection.
`double`	SemiVariance.`evaluate(double[] values, double cutoff, SemiVariance.Direction direction)`	Returns the `SemiVariance` of the designated values against the cutoff in the given direction, using the current value of the biasCorrection instance property.
`double`	SemiVariance.`evaluate(double[] values, double cutoff, SemiVariance.Direction direction, boolean corrected, int start, int length)`	Returns the `SemiVariance` of the designated values against the cutoff in the given direction with the provided bias correction.
`double`	SemiVariance.`evaluate(double[] values, int start, int length)`	Returns the `SemiVariance` of the designated values against the mean, using instance properties varianceDirection and biasCorrection.
`double`	SemiVariance.`evaluate(double[] values, SemiVariance.Direction direction)`	This method calculates `SemiVariance` for the entire array against the mean, using the current value of the biasCorrection instance property.
`double`	Skewness.`evaluate(double[] values, int begin, int length)`	Returns the Skewness of the entries in the specified portion of the input array.
`double`	StandardDeviation.`evaluate(double[] values, double mean)`	Returns the Standard Deviation of the entries in the input array, using the precomputed mean value.
`double`	StandardDeviation.`evaluate(double[] values, double mean, int begin, int length)`	Returns the Standard Deviation of the entries in the specified portion of the input array, using the precomputed mean value.
`double`	StandardDeviation.`evaluate(double[] values, int begin, int length)`	Returns the Standard Deviation of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Variance.`evaluate(double[] values, double mean)`	Returns the variance of the entries in the input array, using the precomputed mean value.
`double`	Variance.`evaluate(double[] values, double[] weights, double mean)`	Returns the weighted variance of the values in the input array, using the precomputed weighted mean value.
`double`	Variance.`evaluate(double[] values, double[] weights, double mean, int begin, int length)`	Returns the weighted variance of the entries in the specified portion of the input array, using the precomputed weighted mean value.
`double`	Variance.`evaluate(double[] values, double[] weights, int begin, int length)`	Returns the weighted variance of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Variance.`evaluate(double[] values, double mean, int begin, int length)`	Returns the variance of the entries in the specified portion of the input array, using the precomputed mean value.
`double`	Variance.`evaluate(double[] values, int begin, int length)`	Returns the variance of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.rank

Methods in org.hipparchus.stat.descriptive.rank that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	Max.`evaluate(double[] values, int begin, int length)`	Returns the maximum of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Median.`evaluate(double[] values, int begin, int length)`	Returns the result of evaluating the statistic over the specified entries in the input array.
`double`	Min.`evaluate(double[] values, int begin, int length)`	Returns the minimum of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Percentile.`evaluate(double p)`	Returns the result of evaluating the statistic over the stored data.
`double`	Percentile.`evaluate(double[] values, double p)`	Returns an estimate of the `p`th percentile of the values in the `values` array.
`double`	Percentile.`evaluate(double[] values, int start, int length)`	Returns an estimate of the `quantile`th percentile of the designated values in the `values` array.
`double`	Percentile.`evaluate(double[] values, int begin, int length, double p)`	Returns an estimate of the `p`th percentile of the values in the `values` array, starting with the element in (0-based) position `begin` in the array and including `length` values.
`double`	RandomPercentile.`evaluate(double percentile, double[] values, int begin, int length)`	Returns an estimate of the given percentile, computed using the designated array segment as input data.
`void`	Percentile.`setData(double[] values, int begin, int length)`	Set the data array.
`void`	Percentile.`setQuantile(double p)`	Sets the value of the quantile field (determines what percentile is computed when evaluate() is called with no quantile argument).

Constructors in org.hipparchus.stat.descriptive.rank that throw MathIllegalArgumentException
Constructor	Description
`Percentile(double quantile)`	Constructs a Percentile with the specific quantile value and the following default method type: `Percentile.EstimationType.LEGACY` default NaN strategy: `NaNStrategy.REMOVED` a Kth Selector : `KthSelector`
`Percentile(double quantile, Percentile.EstimationType estimationType, NaNStrategy nanStrategy, KthSelector kthSelector)`	Constructs a Percentile with the specific quantile value, `Percentile.EstimationType`, `NaNStrategy` and `KthSelector`.

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.summary

Methods in org.hipparchus.stat.descriptive.summary that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	Product.`evaluate(double[] values, double[] weights, int begin, int length)`	Returns the weighted product of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Product.`evaluate(double[] values, int begin, int length)`	Returns the product of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	Sum.`evaluate(double[] values, double[] weights, int begin, int length)`	The weighted sum of the entries in the specified portion of the input array, or 0 if the designated subarray is empty.
`double`	Sum.`evaluate(double[] values, int begin, int length)`	The sum of the entries in the specified portion of the input array, or 0 if the designated subarray is empty.
`double`	SumOfLogs.`evaluate(double[] values, int begin, int length)`	Returns the sum of the natural logs of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
`double`	SumOfSquares.`evaluate(double[] values, int begin, int length)`	Returns the sum of the squares of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.vector

Methods in org.hipparchus.stat.descriptive.vector that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	VectorialCovariance.`increment(double[] v)`	Add a new vector to the sample.

Uses of MathIllegalArgumentException in org.hipparchus.stat.fitting

Methods in org.hipparchus.stat.fitting that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static MixtureMultivariateNormalDistribution`	MultivariateNormalMixtureExpectationMaximization.`estimate(double[][] data, int numComponents)`	Helper method to create a multivariate normal mixture model which can be used to initialize `MultivariateNormalMixtureExpectationMaximization.fit(MixtureMultivariateNormalDistribution)`.
`void`	MultivariateNormalMixtureExpectationMaximization.`fit(MixtureMultivariateNormalDistribution initialMixture)`	Fit a mixture model to the data supplied to the constructor.
`void`	MultivariateNormalMixtureExpectationMaximization.`fit(MixtureMultivariateNormalDistribution initialMixture, int maxIterations, double threshold)`	Fit a mixture model to the data supplied to the constructor.
`double`	EmpiricalDistribution.`inverseCumulativeProbability(double p)`	Computes the quantile function of this distribution.
`void`	EmpiricalDistribution.`load(URL url)`	Computes the empirical distribution using data read from a URL.

Constructors in org.hipparchus.stat.fitting that throw MathIllegalArgumentException
Constructor	Description
`MultivariateNormalMixtureExpectationMaximization(double[][] data)`	Creates an object to fit a multivariate normal mixture model to data.

Uses of MathIllegalArgumentException in org.hipparchus.stat.inference

Methods in org.hipparchus.stat.inference that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`double`	OneWayAnova.`anovaFValue(Collection<double[]> categoryData)`	Computes the ANOVA F-value for a collection of `double[]` arrays.
`double`	OneWayAnova.`anovaPValue(Collection<double[]> categoryData)`	Computes the ANOVA P-value for a collection of `double[]` arrays.
`double`	OneWayAnova.`anovaPValue(Collection<StreamingStatistics> categoryData, boolean allowOneElementData)`	Computes the ANOVA P-value for a collection of `StreamingStatistics`.
`boolean`	OneWayAnova.`anovaTest(Collection<double[]> categoryData, double alpha)`	Performs an ANOVA test, evaluating the null hypothesis that there is no difference among the means of the data categories.
`double`	ChiSquareTest.`chiSquare(double[] expected, long[] observed)`	Computes the Chi-Square statistic comparing `observed` and `expected` frequency counts.
`double`	ChiSquareTest.`chiSquare(long[][] counts)`	Computes the Chi-Square statistic associated with a chi-square test of independence based on the input `counts` array, viewed as a two-way table.
`static double`	InferenceTestUtils.`chiSquare(double[] expected, long[] observed)`
`static double`	InferenceTestUtils.`chiSquare(long[][] counts)`
`double`	ChiSquareTest.`chiSquareDataSetsComparison(long[] observed1, long[] observed2)`	Computes a Chi-Square two sample test statistic comparing bin frequency counts in `observed1` and `observed2`.
`static double`	InferenceTestUtils.`chiSquareDataSetsComparison(long[] observed1, long[] observed2)`
`double`	ChiSquareTest.`chiSquareTest(double[] expected, long[] observed)`	Returns the observed significance level, or p-value, associated with a Chi-square goodness of fit test comparing the `observed` frequency counts to those in the `expected` array.
`boolean`	ChiSquareTest.`chiSquareTest(double[] expected, long[] observed, double alpha)`	Performs a Chi-square goodness of fit test evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level `alpha`.
`double`	ChiSquareTest.`chiSquareTest(long[][] counts)`	Returns the observed significance level, or p-value, associated with a chi-square test of independence based on the input `counts` array, viewed as a two-way table.
`boolean`	ChiSquareTest.`chiSquareTest(long[][] counts, double alpha)`	Performs a chi-square test of independence evaluating the null hypothesis that the classifications represented by the counts in the columns of the input 2-way table are independent of the rows, with significance level `alpha`.
`static double`	InferenceTestUtils.`chiSquareTest(double[] expected, long[] observed)`
`static boolean`	InferenceTestUtils.`chiSquareTest(double[] expected, long[] observed, double alpha)`
`static double`	InferenceTestUtils.`chiSquareTest(long[][] counts)`
`static boolean`	InferenceTestUtils.`chiSquareTest(long[][] counts, double alpha)`
`double`	ChiSquareTest.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)`	Returns the observed significance level, or p-value, associated with a Chi-Square two sample test comparing bin frequency counts in `observed1` and `observed2`.
`boolean`	ChiSquareTest.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`	Performs a Chi-Square two sample test comparing two binned data sets.
`static double`	InferenceTestUtils.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)`
`static boolean`	InferenceTestUtils.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
`double`	GTest.`g(double[] expected, long[] observed)`	Computes the G statistic for Goodness of Fit comparing `observed` and `expected` frequency counts.
`static double`	InferenceTestUtils.`g(double[] expected, long[] observed)`
`double`	GTest.`gDataSetsComparison(long[] observed1, long[] observed2)`	Computes a G (Log-Likelihood Ratio) two sample test statistic for independence comparing frequency counts in `observed1` and `observed2`.
`static double`	InferenceTestUtils.`gDataSetsComparison(long[] observed1, long[] observed2)`
`double`	GTest.`gTest(double[] expected, long[] observed)`	Returns the observed significance level, or p-value, associated with a G-Test for goodness of fit comparing the `observed` frequency counts to those in the `expected` array.
`boolean`	GTest.`gTest(double[] expected, long[] observed, double alpha)`	Performs a G-Test (Log-Likelihood Ratio Test) for goodness of fit evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level `alpha`.
`static double`	InferenceTestUtils.`gTest(double[] expected, long[] observed)`
`static boolean`	InferenceTestUtils.`gTest(double[] expected, long[] observed, double alpha)`
`double`	GTest.`gTestDataSetsComparison(long[] observed1, long[] observed2)`	Returns the observed significance level, or p-value, associated with a G-Value (Log-Likelihood Ratio) for two sample test comparing bin frequency counts in `observed1` and `observed2`.
`boolean`	GTest.`gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`	Performs a G-Test (Log-Likelihood Ratio Test) comparing two binned data sets.
`static double`	InferenceTestUtils.`gTestDataSetsComparison(long[] observed1, long[] observed2)`
`static boolean`	InferenceTestUtils.`gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
`double`	GTest.`gTestIntrinsic(double[] expected, long[] observed)`	Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described in p64-69 of McDonald, J.H.
`static double`	InferenceTestUtils.`gTestIntrinsic(double[] expected, long[] observed)`
`static double`	InferenceTestUtils.`homoscedasticT(double[] sample1, double[] sample2)`
`static double`	InferenceTestUtils.`homoscedasticT(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`
`double`	TTest.`homoscedasticT(double[] sample1, double[] sample2)`	Computes a 2-sample t statistic, under the hypothesis of equal subpopulation variances.
`double`	TTest.`homoscedasticT(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`	Computes a 2-sample t statistic, comparing the means of the datasets described by two `StatisticalSummary` instances, under the assumption of equal subpopulation variances.
`static double`	InferenceTestUtils.`homoscedasticTTest(double[] sample1, double[] sample2)`
`static boolean`	InferenceTestUtils.`homoscedasticTTest(double[] sample1, double[] sample2, double alpha)`
`static double`	InferenceTestUtils.`homoscedasticTTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`
`double`	TTest.`homoscedasticTTest(double[] sample1, double[] sample2)`	Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays, under the assumption that the two samples are drawn from subpopulations with equal variances.
`boolean`	TTest.`homoscedasticTTest(double[] sample1, double[] sample2, double alpha)`	Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`, assuming that the subpopulation variances are equal.
`protected double`	TTest.`homoscedasticTTest(double m1, double m2, double v1, double v2, double n1, double n2)`	Computes p-value for 2-sided, 2-sample t-test, under the assumption of equal subpopulation variances.
`double`	TTest.`homoscedasticTTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`	Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances, under the hypothesis of equal subpopulation variances.
`static double`	InferenceTestUtils.`kolmogorovSmirnovStatistic(double[] x, double[] y)`
`static double`	InferenceTestUtils.`kolmogorovSmirnovStatistic(RealDistribution dist, double[] data)`
`static double`	InferenceTestUtils.`kolmogorovSmirnovTest(double[] x, double[] y)`
`static double`	InferenceTestUtils.`kolmogorovSmirnovTest(double[] x, double[] y, boolean strict)`
`static double`	InferenceTestUtils.`kolmogorovSmirnovTest(RealDistribution dist, double[] data)`
`static double`	InferenceTestUtils.`kolmogorovSmirnovTest(RealDistribution dist, double[] data, boolean strict)`
`static boolean`	InferenceTestUtils.`kolmogorovSmirnovTest(RealDistribution dist, double[] data, double alpha)`
`double`	MannWhitneyUTest.`mannWhitneyU(double[] x, double[] y)`	Computes the Mann-Whitney U statistic comparing means for two independent samples possibly of different lengths.
`double`	MannWhitneyUTest.`mannWhitneyUTest(double[] x, double[] y)`	Returns the asymptotic observed significance level, or p-value, associated with a Mann-Whitney U Test comparing means for two independent samples.
`double`	MannWhitneyUTest.`mannWhitneyUTest(double[] x, double[] y, boolean exact)`	Returns the asymptotic observed significance level, or p-value, associated with a Mann-Whitney U Test comparing means for two independent samples.
`static double`	InferenceTestUtils.`oneWayAnovaFValue(Collection<double[]> categoryData)`
`static double`	InferenceTestUtils.`oneWayAnovaPValue(Collection<double[]> categoryData)`
`static boolean`	InferenceTestUtils.`oneWayAnovaTest(Collection<double[]> categoryData, double alpha)`
`static double`	InferenceTestUtils.`pairedT(double[] sample1, double[] sample2)`
`double`	TTest.`pairedT(double[] sample1, double[] sample2)`	Computes a paired, 2-sample t-statistic based on the data in the input arrays.
`static double`	InferenceTestUtils.`pairedTTest(double[] sample1, double[] sample2)`
`static boolean`	InferenceTestUtils.`pairedTTest(double[] sample1, double[] sample2, double alpha)`
`double`	TTest.`pairedTTest(double[] sample1, double[] sample2)`	Returns the observed significance level, or p-value, associated with a paired, two-sample, two-tailed t-test based on the data in the input arrays.
`boolean`	TTest.`pairedTTest(double[] sample1, double[] sample2, double alpha)`	Performs a paired t-test evaluating the null hypothesis that the mean of the paired differences between `sample1` and `sample2` is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0, with significance level `alpha`.
`static double`	InferenceTestUtils.`rootLogLikelihoodRatio(long k11, long k12, long k21, long k22)`
`static double`	InferenceTestUtils.`t(double[] sample1, double[] sample2)`
`static double`	InferenceTestUtils.`t(double mu, double[] observed)`
`static double`	InferenceTestUtils.`t(double mu, StatisticalSummary sampleStats)`
`static double`	InferenceTestUtils.`t(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`
`double`	TTest.`t(double[] sample1, double[] sample2)`	Computes a 2-sample t statistic, without the hypothesis of equal subpopulation variances.
`double`	TTest.`t(double mu, double[] observed)`	Computes a t statistic given observed values and a comparison constant.
`double`	TTest.`t(double mu, StatisticalSummary sampleStats)`	Computes a t statistic to use in comparing the mean of the dataset described by `sampleStats` to `mu`.
`double`	TTest.`t(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`	Computes a 2-sample t statistic , comparing the means of the datasets described by two `StatisticalSummary` instances, without the assumption of equal subpopulation variances.
`static double`	InferenceTestUtils.`tTest(double[] sample1, double[] sample2)`
`static boolean`	InferenceTestUtils.`tTest(double[] sample1, double[] sample2, double alpha)`
`static double`	InferenceTestUtils.`tTest(double mu, double[] sample)`
`static boolean`	InferenceTestUtils.`tTest(double mu, double[] sample, double alpha)`
`static double`	InferenceTestUtils.`tTest(double mu, StatisticalSummary sampleStats)`
`static boolean`	InferenceTestUtils.`tTest(double mu, StatisticalSummary sampleStats, double alpha)`
`static double`	InferenceTestUtils.`tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`
`static boolean`	InferenceTestUtils.`tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2, double alpha)`
`double`	TTest.`tTest(double[] sample1, double[] sample2)`	Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays.
`boolean`	TTest.`tTest(double[] sample1, double[] sample2, double alpha)`	Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`.
`double`	TTest.`tTest(double mu, double[] sample)`	Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the input array with the constant `mu`.
`boolean`	TTest.`tTest(double mu, double[] sample, double alpha)`	Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which `sample` is drawn equals `mu`.
`protected double`	TTest.`tTest(double m, double mu, double v, double n)`	Computes p-value for 2-sided, 1-sample t-test.
`protected double`	TTest.`tTest(double m1, double m2, double v1, double v2, double n1, double n2)`	Computes p-value for 2-sided, 2-sample t-test.
`double`	TTest.`tTest(double mu, StatisticalSummary sampleStats)`	Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the dataset described by `sampleStats` with the constant `mu`.
`boolean`	TTest.`tTest(double mu, StatisticalSummary sampleStats, double alpha)`	Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which the dataset described by `stats` is drawn equals `mu`.
`double`	TTest.`tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)`	Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances.
`boolean`	TTest.`tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2, double alpha)`	Performs a two-sided t-test evaluating the null hypothesis that `sampleStats1` and `sampleStats2` describe datasets drawn from populations with the same mean, with significance level `alpha`.
`double`	WilcoxonSignedRankTest.`wilcoxonSignedRank(double[] x, double[] y)`	Computes the Wilcoxon signed ranked statistic comparing means for two related samples or repeated measurements on a single sample.
`double`	WilcoxonSignedRankTest.`wilcoxonSignedRankTest(double[] x, double[] y, boolean exactPValue)`	Returns the observed significance level, or p-value, associated with a Wilcoxon signed ranked statistic comparing mean for two related samples or repeated measurements on a single sample.

Uses of MathIllegalArgumentException in org.hipparchus.stat.interval

Methods in org.hipparchus.stat.interval that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static ConfidenceInterval`	BinomialProportion.`getAgrestiCoullInterval(int numberOfTrials, double probabilityOfSuccess, double confidenceLevel)`	Create an Agresti-Coull binomial confidence interval for the true probability of success of an unknown binomial distribution with the given observed number of trials, probability of success and confidence level.
`static ConfidenceInterval`	BinomialProportion.`getClopperPearsonInterval(int numberOfTrials, double probabilityOfSuccess, double confidenceLevel)`	Create a Clopper-Pearson binomial confidence interval for the true probability of success of an unknown binomial distribution with the given observed number of trials, probability of success and confidence level.
`static ConfidenceInterval`	BinomialProportion.`getNormalApproximationInterval(int numberOfTrials, double probabilityOfSuccess, double confidenceLevel)`	Create a binomial confidence interval using normal approximation for the true probability of success of an unknown binomial distribution with the given observed number of trials, probability of success and confidence level.
`static ConfidenceInterval`	BinomialProportion.`getWilsonScoreInterval(int numberOfTrials, double probabilityOfSuccess, double confidenceLevel)`	Create an Wilson score binomial confidence interval for the true probability of success of an unknown binomial distribution with the given observed number of trials, probability of success and confidence level.

Uses of MathIllegalArgumentException in org.hipparchus.stat.regression

Methods in org.hipparchus.stat.regression that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`void`	SimpleRegression.`addData(double[][] data)`	Adds the observations represented by the elements in `data`.
`void`	MillerUpdatingRegression.`addObservation(double[] x, double y)`	Adds an observation to the regression model.
`void`	SimpleRegression.`addObservation(double[] x, double y)`	Adds one observation to the regression model.
`void`	UpdatingMultipleLinearRegression.`addObservation(double[] x, double y)`	Adds one observation to the regression model.
`void`	MillerUpdatingRegression.`addObservations(double[][] x, double[] y)`	Adds multiple observations to the model.
`void`	SimpleRegression.`addObservations(double[][] x, double[] y)`	Adds a series of observations to the regression model.
`void`	UpdatingMultipleLinearRegression.`addObservations(double[][] x, double[] y)`	Adds a series of observations to the regression model.
`double`	RegressionResults.`getCovarianceOfParameters(int i, int j)`	Returns the covariance between regression parameters i and j.
`double`	RegressionResults.`getParameterEstimate(int index)`	Returns the parameter estimate for the regressor at the given index.
`double`	SimpleRegression.`getSlopeConfidenceInterval()`	Returns the half-width of a 95% confidence interval for the slope estimate.
`double`	SimpleRegression.`getSlopeConfidenceInterval(double alpha)`	Returns the half-width of a (100-100*alpha)% confidence interval for the slope estimate.
`double`	RegressionResults.`getStdErrorOfEstimate(int index)`	Returns the standard error of the parameter estimate at index, usually denoted s(b_index).
`void`	OLSMultipleLinearRegression.`newSampleData(double[] y, double[][] x)`	Loads model x and y sample data, overriding any previous sample.
`RegressionResults`	MillerUpdatingRegression.`regress()`	Conducts a regression on the data in the model, using all regressors.
`RegressionResults`	MillerUpdatingRegression.`regress(int numberOfRegressors)`	Conducts a regression on the data in the model, using a subset of regressors.
`RegressionResults`	MillerUpdatingRegression.`regress(int[] variablesToInclude)`	Conducts a regression on the data in the model, using regressors in array Calling this method will change the internal order of the regressors and care is required in interpreting the hatmatrix.
`RegressionResults`	SimpleRegression.`regress()`	Performs a regression on data present in buffers and outputs a RegressionResults object.
`RegressionResults`	SimpleRegression.`regress(int[] variablesToInclude)`	Performs a regression on data present in buffers including only regressors indexed in variablesToInclude and outputs a RegressionResults object
`RegressionResults`	UpdatingMultipleLinearRegression.`regress()`	Performs a regression on data present in buffers and outputs a RegressionResults object
`RegressionResults`	UpdatingMultipleLinearRegression.`regress(int[] variablesToInclude)`	Performs a regression on data present in buffers including only regressors indexed in variablesToInclude and outputs a RegressionResults object
`protected void`	AbstractMultipleLinearRegression.`validateSampleData(double[][] x, double[] y)`	Validates sample data.

Constructors in org.hipparchus.stat.regression that throw MathIllegalArgumentException
Constructor	Description
`MillerUpdatingRegression(int numberOfVariables, boolean includeConstant)`	Primary constructor for the MillerUpdatingRegression.
`MillerUpdatingRegression(int numberOfVariables, boolean includeConstant, double errorTolerance)`	This is the augmented constructor for the MillerUpdatingRegression class.

Uses of MathIllegalArgumentException in org.hipparchus.transform

Methods in org.hipparchus.transform that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static Complex[]`	TransformUtils.`createComplexArray(double[][] dataRI)`	Builds a new array of `Complex` from the specified two dimensional array of real and imaginary parts.
`static int`	TransformUtils.`exactLog2(int n)`	Returns the base-2 logarithm of the specified `int`.
`protected double[]`	FastCosineTransformer.`fct(double[] f)`	Perform the FCT algorithm (including inverse).
`protected double[]`	FastHadamardTransformer.`fht(double[] x)`	The FHT (Fast Hadamard Transformation) which uses only subtraction and addition.
`protected int[]`	FastHadamardTransformer.`fht(int[] x)`	Returns the forward transform of the specified integer data set.
`protected double[]`	FastSineTransformer.`fst(double[] f)`	Perform the FST algorithm (including inverse).
`double[]`	FastCosineTransformer.`transform(double[] f, TransformType type)`	Returns the (forward, inverse) transform of the specified real data set.
`double[]`	FastCosineTransformer.`transform(UnivariateFunction f, double min, double max, int n, TransformType type)`	Returns the (forward, inverse) transform of the specified real function, sampled on the specified interval.
`double[]`	RealTransformer.`transform(double[] f, TransformType type)`	Returns the (forward, inverse) transform of the specified real data set.
`double[]`	RealTransformer.`transform(UnivariateFunction f, double min, double max, int n, TransformType type)`	Returns the (forward, inverse) transform of the specified real function, sampled on the specified interval.

Uses of MathIllegalArgumentException in org.hipparchus.util

Methods in org.hipparchus.util that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static long`	CombinatoricsUtils.`binomialCoefficient(int n, int k)`	Returns an exact representation of the Binomial Coefficient, "`n choose k`", the number of `k`-element subsets that can be selected from an `n`-element set.
`static double`	CombinatoricsUtils.`binomialCoefficientDouble(int n, int k)`	Returns a `double` representation of the Binomial Coefficient, "`n choose k`", the number of `k`-element subsets that can be selected from an `n`-element set.
`static double`	CombinatoricsUtils.`binomialCoefficientLog(int n, int k)`	Returns the natural `log` of the Binomial Coefficient, "`n choose k`", the number of `k`-element subsets that can be selected from an `n`-element set.
`static void`	CombinatoricsUtils.`checkBinomial(int n, int k)`	Check binomial preconditions.
`protected void`	ResizableDoubleArray.`checkContractExpand(double contraction, double expansion)`	Checks the expansion factor and the contraction criterion and raises an exception if the contraction criterion is smaller than the expansion criterion.
`static void`	MathUtils.`checkFinite(double x)`	Check that the argument is a real number.
`static void`	MathUtils.`checkFinite(double[] val)`	Check that all the elements are real numbers.
`static void`	MathArrays.`checkNonNegative(long[] in)`	Check that all entries of the input array are >= 0.
`static void`	MathArrays.`checkNonNegative(long[][] in)`	Check all entries of the input array are >= 0.
`static void`	MathArrays.`checkNotNaN(double[] in)`	Check that no entry of the input array is `NaN`.
`static void`	MathArrays.`checkOrder(double[] val)`	Check that the given array is sorted in strictly increasing order.
`static void`	MathArrays.`checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict)`	Check that the given array is sorted.
`static boolean`	MathArrays.`checkOrder(double[] val, MathArrays.OrderDirection dir, boolean strict, boolean abort)`	Check that the given array is sorted.
`static void`	MathArrays.`checkPositive(double[] in)`	Check that all entries of the input array are strictly positive.
`static void`	MathArrays.`checkRectangular(long[][] in)`	Throws MathIllegalArgumentException if the input array is not rectangular.
`static double[]`	MathArrays.`convolve(double[] x, double[] h)`	Calculates the convolution between two sequences.
`void`	ResizableDoubleArray.`discardFrontElements(int i)`	Discards the `i` initial elements of the array.
`void`	ResizableDoubleArray.`discardMostRecentElements(int i)`	Discards the `i` last elements of the array.
`static double`	MathArrays.`distance(double[] p1, double[] p2)`	Calculates the L₂ (Euclidean) distance between two points.
`static double`	MathArrays.`distance(int[] p1, int[] p2)`	Calculates the L₂ (Euclidean) distance between two points.
`static double`	MathArrays.`distance1(double[] p1, double[] p2)`	Calculates the L₁ (sum of abs) distance between two points.
`static int`	MathArrays.`distance1(int[] p1, int[] p2)`	Calculates the L₁ (sum of abs) distance between two points.
`static double`	MathArrays.`distanceInf(double[] p1, double[] p2)`	Calculates the L_∞ (max of abs) distance between two points.
`static int`	MathArrays.`distanceInf(int[] p1, int[] p2)`	Calculates the L_∞ (max of abs) distance between two points.
`static double[]`	MathArrays.`ebeAdd(double[] a, double[] b)`	Creates an array whose contents will be the element-by-element addition of the arguments.
`static double[]`	MathArrays.`ebeDivide(double[] a, double[] b)`	Creates an array whose contents will be the element-by-element division of the first argument by the second.
`static double[]`	MathArrays.`ebeMultiply(double[] a, double[] b)`	Creates an array whose contents will be the element-by-element multiplication of the arguments.
`static double[]`	MathArrays.`ebeSubtract(double[] a, double[] b)`	Creates an array whose contents will be the element-by-element subtraction of the second argument from the first.
`static long`	CombinatoricsUtils.`factorial(int n)`	Returns n!.
`static double`	CombinatoricsUtils.`factorialDouble(int n)`	Compute n!, the factorial of `n` (the product of the numbers 1 to n), as a `double`.
`static double`	CombinatoricsUtils.`factorialLog(int n)`	Compute the natural logarithm of the factorial of `n`.
`int`	MultidimensionalCounter.`getCount(int... c)`	Convert to unidimensional counter.
`int[]`	MultidimensionalCounter.`getCounts(int index)`	Convert to multidimensional counter.
`Decimal64`	Decimal64.`linearCombination(double[] a, Decimal64[] b)`	Compute a linear combination.
`Decimal64`	Decimal64.`linearCombination(Decimal64[] a, Decimal64[] b)`	Compute a linear combination.
`FieldTuple<T>`	FieldTuple.`linearCombination(double[] a, FieldTuple<T>[] b)`	Compute a linear combination.
`FieldTuple<T>`	FieldTuple.`linearCombination(FieldTuple<T>[] a, FieldTuple<T>[] b)`	Compute a linear combination.
`static double`	MathArrays.`linearCombination(double[] a, double[] b)`	Compute a linear combination accurately.
`Tuple`	Tuple.`linearCombination(double[] a, Tuple[] b)`	Compute a linear combination.
`Tuple`	Tuple.`linearCombination(Tuple[] a, Tuple[] b)`	Compute a linear combination.
`static double[]`	MathArrays.`normalizeArray(double[] values, double normalizedSum)`	Normalizes an array to make it sum to a specified value.
`abstract int`	PivotingStrategy.`pivotIndex(double[] work, int begin, int end)`	Find pivot index of the array so that partition and K^th element selection can be made
`static int`	ArithmeticUtils.`pow(int k, int e)`	Raise an int to an int power.
`static long`	ArithmeticUtils.`pow(long k, int e)`	Raise a long to an int power.
`static BigInteger`	ArithmeticUtils.`pow(BigInteger k, int e)`	Raise a BigInteger to an int power.
`static BigInteger`	ArithmeticUtils.`pow(BigInteger k, long e)`	Raise a BigInteger to a long power.
`static BigInteger`	ArithmeticUtils.`pow(BigInteger k, BigInteger e)`	Raise a BigInteger to a BigInteger power.
`static float`	Precision.`round(float x, int scale, int roundingMethod)`	Rounds the given value to the specified number of decimal places.
`void`	ResizableDoubleArray.`setNumElements(int i)`	This function allows you to control the number of elements contained in this array, and can be used to "throw out" the last n values in an array.
`static void`	MathArrays.`sortInPlace(double[] x, double[]... yList)`	Sort an array in ascending order in place and perform the same reordering of entries on other arrays.
`static void`	MathArrays.`sortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList)`	Sort an array in place and perform the same reordering of entries on other arrays.
`static long`	CombinatoricsUtils.`stirlingS2(int n, int k)`	Returns the Stirling number of the second kind, "`S(n,k)`", the number of ways of partitioning an `n`-element set into `k` non-empty subsets.
`static boolean`	MathArrays.`verifyValues(double[] values, double[] weights, int begin, int length)`	This method is used to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.
`static boolean`	MathArrays.`verifyValues(double[] values, double[] weights, int begin, int length, boolean allowEmpty)`	This method is used to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.
`static boolean`	MathArrays.`verifyValues(double[] values, int begin, int length)`	This method is used to verify that the input parameters designate a subarray of positive length.
`static boolean`	MathArrays.`verifyValues(double[] values, int begin, int length, boolean allowEmpty)`	This method is used to verify that the input parameters designate a subarray of positive length.

Constructors in org.hipparchus.util that throw MathIllegalArgumentException
Constructor	Description
`MultidimensionalCounter(int... size)`	Create a counter.
`ResizableDoubleArray(int initialCapacity)`	Creates an instance with the specified initial capacity.
`ResizableDoubleArray(int initialCapacity, double expansionFactor)`	Creates an instance with the specified initial capacity and expansion factor.
`ResizableDoubleArray(int initialCapacity, double expansionFactor, double contractionCriterion)`	Creates an instance with the specified initial capacity, expansion factor, and contraction criteria.
`ResizableDoubleArray(int initialCapacity, double expansionFactor, double contractionCriterion, ResizableDoubleArray.ExpansionMode expansionMode, double... data)`	Creates an instance with the specified properties.

Uses of Classorg.hipparchus.exception.MathIllegalArgumentException

Uses of MathIllegalArgumentException in org.hipparchus

Uses of MathIllegalArgumentException in org.hipparchus.analysis

Uses of MathIllegalArgumentException in org.hipparchus.analysis.differentiation

Uses of MathIllegalArgumentException in org.hipparchus.analysis.function

Uses of MathIllegalArgumentException in org.hipparchus.analysis.integration

Uses of MathIllegalArgumentException in org.hipparchus.analysis.integration.gauss

Uses of MathIllegalArgumentException in org.hipparchus.analysis.interpolation

Uses of MathIllegalArgumentException in org.hipparchus.analysis.polynomials

Uses of MathIllegalArgumentException in org.hipparchus.analysis.solvers

Uses of MathIllegalArgumentException in org.hipparchus.clustering

Uses of MathIllegalArgumentException in org.hipparchus.clustering.distance

Uses of MathIllegalArgumentException in org.hipparchus.complex

Uses of MathIllegalArgumentException in org.hipparchus.dfp

Uses of MathIllegalArgumentException in org.hipparchus.distribution

Uses of MathIllegalArgumentException in org.hipparchus.distribution.continuous

Uses of MathIllegalArgumentException in org.hipparchus.distribution.discrete

Uses of MathIllegalArgumentException in org.hipparchus.distribution.multivariate

Uses of MathIllegalArgumentException in org.hipparchus.filtering.kalman

Uses of MathIllegalArgumentException in org.hipparchus.fraction

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.threed

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.twod

Uses of MathIllegalArgumentException in org.hipparchus.geometry.euclidean.twod.hull

Uses of MathIllegalArgumentException in org.hipparchus.geometry.hull

Uses of MathIllegalArgumentException in org.hipparchus.geometry.spherical.oned

Uses of MathIllegalArgumentException in org.hipparchus.geometry.spherical.twod

Uses of MathIllegalArgumentException in org.hipparchus.linear

Uses of MathIllegalArgumentException in org.hipparchus.migration.exception

Uses of MathIllegalArgumentException in org.hipparchus.migration.genetics

Uses of MathIllegalArgumentException in org.hipparchus.migration.geometry.euclidean.threed

Uses of MathIllegalArgumentException in org.hipparchus.migration.linear

Uses of MathIllegalArgumentException in org.hipparchus.migration.ode

Uses of MathIllegalArgumentException in org.hipparchus.migration.stat.regression

Uses of MathIllegalArgumentException in org.hipparchus.ode

Uses of MathIllegalArgumentException in org.hipparchus.ode.events

Uses of MathIllegalArgumentException in org.hipparchus.ode.nonstiff

Uses of MathIllegalArgumentException in org.hipparchus.optim.nonlinear.scalar

Uses of MathIllegalArgumentException in org.hipparchus.optim.nonlinear.scalar.noderiv

Uses of MathIllegalArgumentException in org.hipparchus.random

Uses of MathIllegalArgumentException in org.hipparchus.special

Uses of MathIllegalArgumentException in org.hipparchus.stat

Uses of MathIllegalArgumentException in org.hipparchus.stat.correlation

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.moment

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.rank

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.summary

Uses of MathIllegalArgumentException in org.hipparchus.stat.descriptive.vector

Uses of MathIllegalArgumentException in org.hipparchus.stat.fitting

Uses of MathIllegalArgumentException in org.hipparchus.stat.inference

Uses of MathIllegalArgumentException in org.hipparchus.stat.interval

Uses of MathIllegalArgumentException in org.hipparchus.stat.regression

Uses of MathIllegalArgumentException in org.hipparchus.transform

Uses of MathIllegalArgumentException in org.hipparchus.util

Uses of Class
org.hipparchus.exception.MathIllegalArgumentException