Uses of Class org.hipparchus.exception.MathIllegalArgumentException (Hipparchus::Core 4.0.2 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.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.fraction	Fraction number type and fraction number formatting.
org.hipparchus.linear	Linear algebra support.
org.hipparchus.random	Random number and random data generators.
org.hipparchus.special	Implementations of special functions such as Beta and Gamma.
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`	CalculusFieldElement.`atan2(T x)`	Two arguments arc tangent operation.
`T`	CalculusFieldElement.`hypot(T y)`	Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`default T`	CalculusFieldElement.`linearCombination(double[] a, T[] b)`	Compute a linear combination.
`T`	CalculusFieldElement.`linearCombination(T[] a, T[] b)`	Compute a linear combination.
`T`	CalculusFieldElement.`pow(T e)`	Power operation.

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 CalculusFieldElement<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.
`T`	Derivative.`compose(double... f)`	Compute composition of the instance by a univariate function.
`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.
`abstract S`	FieldUnivariateDerivative.`getDerivative(int n)`	Get a derivative from the univariate derivative.
`abstract double`	UnivariateDerivative.`getDerivative(int n)`	Get a derivative from the univariate derivative.
`double`	Derivative.`getPartialDerivative(int... orders)`	Get a partial derivative.
`double`	DerivativeStructure.`getPartialDerivative(int... orders)`	Get a partial derivative.
`S`	FieldDerivative.`getPartialDerivative(int... orders)`	Get a partial derivative.
`T`	FieldDerivativeStructure.`getPartialDerivative(int... orders)`	Get a partial derivative.
`T`	FieldGradient.`getPartialDerivative(int n)`	Get the partial derivative with respect to one parameter.
`T`	FieldGradient.`getPartialDerivative(int... orders)`	Get a partial derivative.
`S`	FieldUnivariateDerivative.`getPartialDerivative(int... orders)`	Get a partial derivative.
`double`	Gradient.`getPartialDerivative(int n)`	Get the partial derivative with respect to one parameter.
`double`	Gradient.`getPartialDerivative(int... orders)`	Get a partial derivative.
`double`	SparseGradient.`getPartialDerivative(int... orders)`	Get a partial derivative.
`double`	UnivariateDerivative.`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 CalculusFieldElement<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.
`<T extends Derivative<T>> T`	UnivariateDifferentiableFunction.`value(T x)`	Compute the value for the function.
`<T extends Derivative<T>> T[][]`	UnivariateDifferentiableMatrixFunction.`value(T x)`	Compute the value for the function.
`<T extends Derivative<T>> T[]`	UnivariateDifferentiableVectorFunction.`value(T 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
`FieldGradient(FieldDerivativeStructure<T> ds)`	Build an instance from a `FieldDerivativeStructure`.
`FieldUnivariateDerivative1(FieldDerivativeStructure<T> ds)`	Build an instance from a `FieldDerivativeStructure`.
`FieldUnivariateDerivative2(FieldDerivativeStructure<T> ds)`	Build an instance from a `FieldDerivativeStructure`.
`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.
`Gradient(DerivativeStructure ds)`	Build an instance from a `DerivativeStructure`.
`UnivariateDerivative1(DerivativeStructure ds)`	Build an instance from a `DerivativeStructure`.
`UnivariateDerivative2(DerivativeStructure ds)`	Build an instance from a `DerivativeStructure`.

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`.
`<T extends Derivative<T>> T`	Gaussian.`value(T t)`	Compute the value for the function.
`double`	HarmonicOscillator.Parametric.`value(double x, double... param)`	Computes the value of the harmonic oscillator at `x`.
`<T extends Derivative<T>> T`	HarmonicOscillator.`value(T t)`	Compute the value for the 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.
`<T extends Derivative<T>> T`	Logit.`value(T t)`	Compute the value for the function.
`double`	Sigmoid.Parametric.`value(double x, double... param)`	Computes the value of the sigmoid at `x`.
`<T extends Derivative<T>> T`	Sigmoid.`value(T t)`	Compute the value for the function.
`<T extends Derivative<T>> T`	Sinc.`value(T t)`	Compute the value for the 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)`	Simple constructor.
`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 T`	FieldMidPointIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`protected T`	FieldTrapezoidIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`protected T`	IterativeLegendreFieldGaussIntegrator.`doIntegrate()`	Method for implementing actual integration algorithms in derived classes.
`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.
`T`	BaseAbstractFieldUnivariateIntegrator.`integrate(int maxEval, CalculusFieldUnivariateFunction<T> f, T lower, T upper)`	Integrate the function in the given interval.
`double`	BaseAbstractUnivariateIntegrator.`integrate(int maxEval, UnivariateFunction f, double lower, double upper)`	Integrate the function in the given interval.
`T`	FieldUnivariateIntegrator.`integrate(int maxEval, CalculusFieldUnivariateFunction<T> f, T min, T max)`	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`	BaseAbstractFieldUnivariateIntegrator.`setup(int maxEval, CalculusFieldUnivariateFunction<T> f, T lower, T upper)`	Prepare for computation.
`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
`BaseAbstractFieldUnivariateIntegrator(Field<T> field, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Construct an integrator with given accuracies and iteration counts.
`BaseAbstractFieldUnivariateIntegrator(Field<T> field, int minimalIterationCount, int maximalIterationCount)`	Construct an integrator with given iteration counts.
`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.
`FieldMidPointIntegrator(Field<T> field, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a midpoint integrator with given accuracies and iterations counts.
`FieldMidPointIntegrator(Field<T> field, int minimalIterationCount, int maximalIterationCount)`	Build a midpoint integrator with given iteration counts.
`FieldRombergIntegrator(Field<T> field, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a Romberg integrator with given accuracies and iterations counts.
`FieldRombergIntegrator(Field<T> field, int minimalIterationCount, int maximalIterationCount)`	Build a Romberg integrator with given iteration counts.
`FieldSimpsonIntegrator(Field<T> field, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a Simpson integrator with given accuracies and iterations counts.
`FieldSimpsonIntegrator(Field<T> field, int minimalIterationCount, int maximalIterationCount)`	Build a Simpson integrator with given iteration counts.
`FieldTrapezoidIntegrator(Field<T> field, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Build a trapezoid integrator with given accuracies and iterations counts.
`FieldTrapezoidIntegrator(Field<T> field, int minimalIterationCount, int maximalIterationCount)`	Build a trapezoid integrator with given iteration counts.
`IterativeLegendreFieldGaussIntegrator(Field<T> field, int n, double relativeAccuracy, double absoluteAccuracy)`	Builds an integrator with given accuracies.
`IterativeLegendreFieldGaussIntegrator(Field<T> field, int n, double relativeAccuracy, double absoluteAccuracy, int minimalIterationCount, int maximalIterationCount)`	Builds an integrator with given accuracies and iterations counts.
`IterativeLegendreFieldGaussIntegrator(Field<T> field, int n, int minimalIterationCount, int maximalIterationCount)`	Builds 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 abstract Pair<double[],double[]>`	AbstractRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected Pair<double[],double[]>`	ConvertingRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected abstract Pair<T[],T[]>`	FieldAbstractRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`protected Pair<T[],T[]>`	FieldHermiteRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`Pair<T[],T[]>`	FieldLaguerreRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`Pair<T[],T[]>`	FieldLegendreRuleFactory.`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<double[],double[]>`	LegendreRuleFactory.`computeRule(int numberOfPoints)`	Computes the rule for the given order.
`Pair<double[],double[]>`	AbstractRuleFactory.`getRule(int numberOfPoints)`	Gets a copy of the quadrature rule with the given number of integration points.
`Pair<T[],T[]>`	FieldAbstractRuleFactory.`getRule(int numberOfPoints)`	Gets a copy of the quadrature rule with the given number of integration points.
`Pair<T[],T[]>`	FieldRuleFactory.`getRule(int numberOfPoints)`	Gets a copy of the quadrature rule with the given number of integration points.
`Pair<double[],double[]>`	RuleFactory.`getRule(int numberOfPoints)`	Gets a copy of the quadrature rule with the given number of integration points.
`FieldGaussIntegrator<T>`	FieldGaussIntegratorFactory.`legendre(int numberOfPoints, T lowerBound, T upperBound)`	Creates a Gauss-Legendre integrator of the given order.
`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
`FieldGaussIntegrator(Pair<T[],T[]> pointsAndWeights)`	Creates an integrator from the given pair of points (first element of the pair) and weights (second element of the pair.
`FieldGaussIntegrator(T[] points, T[] weights)`	Creates an integrator from the given `points` and `weights`.
`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.
`SymmetricFieldGaussIntegrator(Pair<T[],T[]> pointsAndWeights)`	Creates an integrator from the given pair of points (first element of the pair) and weights (second element of the pair.
`SymmetricFieldGaussIntegrator(T[] points, T[] weights)`	Creates an integrator from the given `points` and `weights`.
`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
`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.
`<T extends CalculusFieldElement<T>> FieldPolynomialSplineFunction<T>`	AkimaSplineInterpolator.`interpolate(T[] xvals, T[] 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.
`FieldBilinearInterpolatingFunction<T>`	FieldBilinearInterpolator.`interpolate(T[] xval, T[] yval, T[][] fval)`	Compute an interpolating function for the dataset.
`CalculusFieldBivariateFunction<T>`	FieldBivariateGridInterpolator.`interpolate(T[] xval, T[] yval, T[][] fval)`	Compute an interpolating function for the dataset.
`<T extends CalculusFieldElement<T>> CalculusFieldUnivariateFunction<T>`	FieldUnivariateInterpolator.`interpolate(T[] xval, T[] yval)`	Compute an interpolating function for the dataset.
`PolynomialSplineFunction`	LinearInterpolator.`interpolate(double[] x, double[] y)`	Computes a linear interpolating function for the data set.
`<T extends CalculusFieldElement<T>> FieldPolynomialSplineFunction<T>`	LinearInterpolator.`interpolate(T[] x, T[] 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.
`<T extends CalculusFieldElement<T>> FieldPolynomialSplineFunction<T>`	SplineInterpolator.`interpolate(T[] x, T[] 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.
`<T extends Derivative<T>> T[]`	HermiteInterpolator.`value(T x)`	Compute the value for the function.
`double`	PiecewiseBicubicSplineInterpolatingFunction.`value(double x, double y)`	Compute the value for the function.
`<T extends CalculusFieldElement<T>> T`	PiecewiseBicubicSplineInterpolatingFunction.`value(T x, T 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)`	Simple constructor.
`BilinearInterpolatingFunction(double[] xVal, double[] yVal, double[][] fVal)`	Simple constructor.
`FieldBilinearInterpolatingFunction(T[] xVal, T[] yVal, T[][] fVal)`	Simple constructor.
`FieldGridAxis(T[] grid, int n)`	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)`	Simple constructor.
`TricubicInterpolatingFunction(double[] x, double[] y, double[] z, double[][][] f, double[][][] dFdX, double[][][] dFdY, double[][][] dFdZ, double[][][] d2FdXdY, double[][][] d2FdXdZ, double[][][] d2FdYdZ, double[][][] d3FdXdYdZ)`	Simple constructor.

Uses of MathIllegalArgumentException in org.hipparchus.analysis.polynomials

Methods in org.hipparchus.analysis.polynomials that throw MathIllegalArgumentException
Modifier and Type	Method	Description
`static void`	SmoothStepFactory.`checkBetweenZeroAndOneIncluded(double input)`	Check that input is between [0:1].
`protected static <T extends CalculusFieldElement<T>> T[]`	FieldPolynomialFunction.`differentiate(T[] coefficients)`	Returns the coefficients of the derivative of the polynomial with the given coefficients.
`protected static double[]`	PolynomialFunction.`differentiate(double[] coefficients)`	Returns the coefficients of the derivative of the polynomial with the given coefficients.
`protected static <T extends CalculusFieldElement<T>> T`	FieldPolynomialFunction.`evaluate(T[] coefficients, T argument)`	Uses Horner's Method to evaluate the polynomial with the given coefficients at the argument.
`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.
`<T extends Derivative<T>> T`	PolynomialFunction.`value(T t)`	Compute the value for the function.
`<T extends CalculusFieldElement<T>> T`	PolynomialFunction.`value(T t)`	Compute the value of the function.
`T`	SmoothStepFactory.FieldSmoothStepFunction.`value(double leftEdge, double rightEdge, T x)`	Compute the value of the smoothstep function for the given edges and argument.
`double`	SmoothStepFactory.QuadraticSmoothStepFunction.`value(double leftEdge, double rightEdge, double x)`	Compute the value of the smoothstep function for the given edges and argument.
`double`	SmoothStepFactory.SmoothStepFunction.`value(double leftEdge, double rightEdge, double x)`	Compute the value of the smoothstep function for the given edges and argument.
`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
`FieldPolynomialFunction(T[] c)`	Construct a polynomial with the given coefficients.
`FieldPolynomialFunctionLagrangeForm(T[] x, T[] y)`	Construct a Lagrange polynomial with the given abscissas and function values.
`FieldPolynomialSplineFunction(T[] knots, FieldPolynomialFunction<T>[] polynomials)`	Construct a polynomial spline function with the given segment delimiters and interpolating polynomials.
`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 CalculusFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(CalculusFieldUnivariateFunction<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 CalculusFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(CalculusFieldUnivariateFunction<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 CalculusFieldElement<T>> T[]`	UnivariateSolverUtils.`bracket(CalculusFieldUnivariateFunction<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, CalculusFieldUnivariateFunction<T> f, T min, T max, AllowedSolution allowedSolution)`	Solve for a zero in the given interval.
`T`	FieldBracketingNthOrderBrentSolver.`solve(int maxEval, CalculusFieldUnivariateFunction<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.`solveAllComplex(double[] coefficients, int maxEval, 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, CalculusFieldUnivariateFunction<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, CalculusFieldUnivariateFunction<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, CalculusFieldUnivariateFunction<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.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.
`double`	RootsOfUnity.`getReal(int k)`	Get the real part of the `k`-th `n`-th root of unity.
`Complex`	Complex.`linearCombination(double[] a, Complex[] b)`	Compute a linear combination.
`Complex`	Complex.`linearCombination(Complex[] a, Complex[] b)`	Compute a linear combination.
`FieldComplex<T>`	FieldComplex.`linearCombination(double[] a, FieldComplex<T>[] b)`	Compute a linear combination.
`FieldComplex<T>`	FieldComplex.`linearCombination(FieldComplex<T>[] a, FieldComplex<T>[] b)`	Compute a linear combination.
`List<Complex>`	Complex.`nthRoot(int n)`	Computes the n-th roots of this complex number.
`List<FieldComplex<T>>`	FieldComplex.`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.
`static <T extends CalculusFieldElement<T>> FieldComplex<T>`	ComplexUtils.`polar2Complex(T r, T 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. The number of dimensions is equal to the length of the mean vector and to the number of rows and columns of the covariance matrix.
`MultivariateNormalDistribution(double[] means, double[][] covariances, double singularMatrixCheckTolerance)`	Creates a multivariate normal distribution with the given mean vector and covariance matrix. The number of dimensions is equal to the length of the mean vector and to the number of rows and columns of the covariance matrix.
`MultivariateNormalDistribution(RandomGenerator rng, double[] means, double[][] covariances, double singularMatrixCheckTolerance)`	Creates a multivariate normal distribution with the given mean vector and covariance matrix.

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.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.
`FieldDecompositionSolver<T>`	FieldMatrixDecomposer.`decompose(FieldMatrix<T> a)`	Get a solver for finding the A × X = B solution in least square sense.
`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.
`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.
`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>`	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.
`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, 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, 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`	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, 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.
`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.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.
`static <T extends CalculusFieldElement<T>> T`	Gamma.`logGamma1p(T 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.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.
`B`	Blendable.`blendArithmeticallyWith(B other, double blendingValue)`	Blend arithmetically this instance with another one.
`B`	FieldBlendable.`blendArithmeticallyWith(B other, T blendingValue)`	Blend arithmetically this instance with another one.
`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 <T extends CalculusFieldElement<T>> void`	MathArrays.`checkOrder(T[] val)`	Check that the given array is sorted in strictly increasing order.
`static <T extends CalculusFieldElement<T>> void`	MathArrays.`checkOrder(T[] val, MathArrays.OrderDirection dir, boolean strict)`	Check that the given array is sorted.
`static <T extends CalculusFieldElement<T>> boolean`	MathArrays.`checkOrder(T[] 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!
`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.
`Binary64`	Binary64.`linearCombination(double[] a, Binary64[] b)`	Compute a linear combination.
`Binary64`	Binary64.`linearCombination(Binary64[] a, Binary64[] 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, RoundingMode 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.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.fraction

Uses of MathIllegalArgumentException in org.hipparchus.linear

Uses of MathIllegalArgumentException in org.hipparchus.random

Uses of MathIllegalArgumentException in org.hipparchus.special

Uses of MathIllegalArgumentException in org.hipparchus.util

Uses of Class
org.hipparchus.exception.MathIllegalArgumentException