# Uses of Class
org.apache.commons.math3.exception.DimensionMismatchException

Packages that use DimensionMismatchException
Package
Description
org.apache.commons.math3
Common classes used throughout the commons-math library.
org.apache.commons.math3.analysis.differentiation
This package holds the main interfaces and basic building block classes dealing with differentiation.
org.apache.commons.math3.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.apache.commons.math3.analysis.integration.gauss
Gauss family of quadrature schemes.
org.apache.commons.math3.analysis.interpolation
Univariate real functions interpolation algorithms.
org.apache.commons.math3.analysis.polynomials
Univariate real polynomials implementations, seen as differentiable univariate real functions.
org.apache.commons.math3.complex
Complex number type and implementations of complex transcendental functions.
org.apache.commons.math3.dfp
Decimal floating point library for Java
org.apache.commons.math3.distribution
Implementations of common discrete and continuous distributions.
org.apache.commons.math3.distribution.fitting
Fitting of parameters against distributions.
org.apache.commons.math3.filter
Implementations of common discrete-time linear filters.
org.apache.commons.math3.genetics
This package provides Genetic Algorithms components and implementations.
org.apache.commons.math3.geometry.euclidean.threed
This package provides basic 3D geometry components.
org.apache.commons.math3.geometry.euclidean.twod
This package provides basic 2D geometry components.
org.apache.commons.math3.linear
Linear algebra support.
org.apache.commons.math3.ml.distance
Common distance measures.
org.apache.commons.math3.ode
This package provides classes to solve Ordinary Differential Equations problems.
org.apache.commons.math3.ode.nonstiff
This package provides classes to solve non-stiff Ordinary Differential Equations problems.
org.apache.commons.math3.optim.nonlinear.scalar.noderiv
This package provides optimization algorithms that do not require derivatives.
org.apache.commons.math3.optim.nonlinear.vector
Algorithms for optimizing a vector function.
org.apache.commons.math3.optimization.direct
This package provides optimization algorithms that don't require derivatives.
org.apache.commons.math3.random
Random number and random data generators.
org.apache.commons.math3.stat
Data storage, manipulation and summary routines.
org.apache.commons.math3.stat.correlation
Correlations/Covariance computations.
org.apache.commons.math3.stat.descriptive
Generic univariate summary statistic objects.
org.apache.commons.math3.stat.descriptive.moment
Summary statistics based on moments.
org.apache.commons.math3.stat.inference
Classes providing hypothesis testing.
org.apache.commons.math3.transform
Implementations of transform methods, including Fast Fourier transforms.
org.apache.commons.math3.util
Convenience routines and common data structures used throughout the commons-math library.

## Uses of DimensionMismatchException in org.apache.commons.math3

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

## Uses of DimensionMismatchException in org.apache.commons.math3.analysis.differentiation

Methods in org.apache.commons.math3.analysis.differentiation that throw DimensionMismatchException
Modifier and Type
Method
Description
`DerivativeStructure`
DerivativeStructure.`add(DerivativeStructure 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.
`void`
DSCompiler.`checkCompatibility(DSCompiler compiler)`
Check rules set compatibility.
`DerivativeStructure`
DerivativeStructure.`compose(double... f)`
Compute composition of the instance by a univariate function.
`DerivativeStructure`
DerivativeStructure.`divide(DerivativeStructure a)`
Compute this ÷ a.
`double`
DerivativeStructure.`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(this2 +y2) 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(x2 +y2) 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.
`SparseGradient`
SparseGradient.`linearCombination(SparseGradient[] a, SparseGradient[] b)`
Compute a linear combination.
`DerivativeStructure`
DerivativeStructure.`multiply(DerivativeStructure a)`
Compute this × a.
`DerivativeStructure`
DerivativeStructure.`pow(DerivativeStructure e)`
Power operation.
`DerivativeStructure`
DerivativeStructure.`remainder(DerivativeStructure a)`
IEEE remainder operator.
`DerivativeStructure`
DerivativeStructure.`subtract(DerivativeStructure a)`
Compute this - a.
`DerivativeStructure`
UnivariateDifferentiableFunction.`value(DerivativeStructure t)`
Simple mathematical function.
Constructors in org.apache.commons.math3.analysis.differentiation that throw DimensionMismatchException
Modifier
Constructor
Description
``
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2)`
Linear combination constructor.
``
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3)`
Linear combination constructor.
``
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3, double a4, DerivativeStructure ds4)`
Linear combination constructor.
``
`DerivativeStructure(int parameters, int order, double... derivatives)`
Build an instance from all its derivatives.

## Uses of DimensionMismatchException in org.apache.commons.math3.analysis.function

Methods in org.apache.commons.math3.analysis.function that throw DimensionMismatchException
Modifier and Type
Method
Description
`double[]`
Gaussian.Parametric.`gradient(double x, double... param)`
Computes the value of the gradient at `x`.
`double[]`
HarmonicOscillator.Parametric.`gradient(double x, double... param)`
Computes the value of the gradient at `x`.
`double[]`
Logistic.Parametric.`gradient(double x, double... param)`
Computes the value of the gradient at `x`.
`double[]`
Logit.Parametric.`gradient(double x, double... param)`
Computes the value of the gradient at `x`.
`double[]`
Sigmoid.Parametric.`gradient(double x, double... param)`
Computes the value of the gradient at `x`.
`double`
Gaussian.Parametric.`value(double x, double... param)`
Computes the value of the Gaussian at `x`.
`DerivativeStructure`
Gaussian.`value(DerivativeStructure t)`
Simple mathematical function.
`double`
HarmonicOscillator.Parametric.`value(double x, double... param)`
Computes the value of the harmonic oscillator at `x`.
`DerivativeStructure`
HarmonicOscillator.`value(DerivativeStructure t)`
Simple mathematical function.
`double`
Logistic.Parametric.`value(double x, double... param)`
Computes the value of the sigmoid at `x`.
`double`
Logit.Parametric.`value(double x, double... param)`
Computes the value of the logit at `x`.
`double`
Sigmoid.Parametric.`value(double x, double... param)`
Computes the value of the sigmoid at `x`.
`DerivativeStructure`
Sigmoid.`value(DerivativeStructure t)`
Simple mathematical function.
`DerivativeStructure`
Sinc.`value(DerivativeStructure t)`
Simple mathematical function.
Constructors in org.apache.commons.math3.analysis.function that throw DimensionMismatchException
Modifier
Constructor
Description
``
`StepFunction(double[] x, double[] y)`
Builds a step function from a list of arguments and the corresponding values.

## Uses of DimensionMismatchException in org.apache.commons.math3.analysis.integration.gauss

Methods in org.apache.commons.math3.analysis.integration.gauss that throw DimensionMismatchException
Modifier and Type
Method
Description
`protected void`
BaseRuleFactory.`addRule(Pair<T[],T[]> rule)`
Stores a rule.
`protected abstract Pair<T[],T[]>`
BaseRuleFactory.`computeRule(int numberOfPoints)`
Computes the rule for the given order.
`protected Pair<Double[],Double[]>`
HermiteRuleFactory.`computeRule(int numberOfPoints)`
Computes the rule for the given order.
`protected Pair<BigDecimal[],BigDecimal[]>`
LegendreHighPrecisionRuleFactory.`computeRule(int numberOfPoints)`
Computes the rule for the given order.
`protected Pair<Double[],Double[]>`
LegendreRuleFactory.`computeRule(int numberOfPoints)`
Computes the rule for the given order.
`Pair<double[],double[]>`
BaseRuleFactory.`getRule(int numberOfPoints)`
Gets a copy of the quadrature rule with the given number of integration points.
`protected Pair<T[],T[]>`
BaseRuleFactory.`getRuleInternal(int numberOfPoints)`
Gets a rule.
Constructors in org.apache.commons.math3.analysis.integration.gauss that throw DimensionMismatchException
Modifier
Constructor
Description
``
`GaussIntegrator(double[] points, double[] weights)`
Creates an integrator from the given `points` and `weights`.
``
`SymmetricGaussIntegrator(double[] points, double[] weights)`
Creates an integrator from the given `points` and `weights`.

## Uses of DimensionMismatchException in org.apache.commons.math3.analysis.interpolation

Methods in org.apache.commons.math3.analysis.interpolation that throw DimensionMismatchException
Modifier and Type
Method
Description
`void`
FieldHermiteInterpolator.`addSamplePoint(T x, T[]... value)`
Add a sample point.
`protected static double[]`
DividedDifferenceInterpolator.`computeDividedDifference(double[] x, double[] y)`
Return a copy of the divided difference array.
`PolynomialSplineFunction`
AkimaSplineInterpolator.`interpolate(double[] xvals, double[] yvals)`
Computes an interpolating function for the data set.
`BicubicInterpolatingFunction`
BicubicInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`
Compute an interpolating function for the dataset.
`BicubicSplineInterpolatingFunction`
BicubicSplineInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`
Deprecated.
Compute an interpolating function for the dataset.
`BivariateFunction`
BivariateGridInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`
Compute an interpolating function for the dataset.
`PolynomialFunctionNewtonForm`
DividedDifferenceInterpolator.`interpolate(double[] x, double[] y)`
Compute an interpolating function for the dataset.
`PolynomialSplineFunction`
LinearInterpolator.`interpolate(double[] x, double[] y)`
Computes a linear interpolating function for the data set.
`final 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`
MicrosphereInterpolator.`interpolate(double[][] xval, double[] yval)`
Deprecated.
Computes an interpolating function for the data set.
`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.
`BicubicSplineInterpolatingFunction`
SmoothingPolynomialBicubicSplineInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)`
Deprecated.
Compute an interpolating function for the dataset.
`PolynomialSplineFunction`
SplineInterpolator.`interpolate(double[] x, double[] y)`
Computes an interpolating function for the data set.
`TricubicInterpolatingFunction`
TricubicInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)`
Compute an interpolating function for the dataset.
`TricubicSplineInterpolatingFunction`
TricubicSplineInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)`
Deprecated.
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.
`final double[]`
LoessInterpolator.`smooth(double[] xval, double[] yval)`
Compute a loess fit on the data at the original abscissae.
`final double[]`
LoessInterpolator.`smooth(double[] xval, double[] yval, double[] weights)`
Compute a weighted loess fit on the data at the original abscissae.
`double`
MicrosphereInterpolatingFunction.`value(double[] point)`
Deprecated.
Constructors in org.apache.commons.math3.analysis.interpolation that throw DimensionMismatchException
Modifier
Constructor
Description
``
`BicubicInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)`
``
`BicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)`
Deprecated.
``
`BicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY, boolean initializeDerivatives)`
Deprecated.
``
`MicrosphereInterpolatingFunction(double[][] xval, double[] yval, int brightnessExponent, int microsphereElements, UnitSphereRandomVectorGenerator rand)`
Deprecated.
``
`PiecewiseBicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f)`
``
`TricubicInterpolatingFunction(double[] x, double[] y, double[] z, double[][][] f, double[][][] dFdX, double[][][] dFdY, double[][][] dFdZ, double[][][] d2FdXdY, double[][][] d2FdXdZ, double[][][] d2FdYdZ, double[][][] d3FdXdYdZ)`
``
`TricubicSplineInterpolatingFunction(double[] x, double[] y, double[] z, double[][][] f, double[][][] dFdX, double[][][] dFdY, double[][][] dFdZ, double[][][] d2FdXdY, double[][][] d2FdXdZ, double[][][] d2FdYdZ, double[][][] d3FdXdYdZ)`
Deprecated.

## Uses of DimensionMismatchException in org.apache.commons.math3.analysis.polynomials

Methods in org.apache.commons.math3.analysis.polynomials that throw DimensionMismatchException
Modifier and Type
Method
Description
`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.
`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.apache.commons.math3.analysis.polynomials that throw DimensionMismatchException
Modifier
Constructor
Description
``
`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 DimensionMismatchException in org.apache.commons.math3.complex

Constructors in org.apache.commons.math3.complex that throw DimensionMismatchException
Modifier
Constructor
Description
``
`Quaternion(double scalar, double[] v)`
Builds a quaternion from scalar and vector parts.

## Uses of DimensionMismatchException in org.apache.commons.math3.dfp

Methods in org.apache.commons.math3.dfp that throw DimensionMismatchException
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 DimensionMismatchException in org.apache.commons.math3.distribution

Methods in org.apache.commons.math3.distribution that throw DimensionMismatchException
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.apache.commons.math3.distribution that throw DimensionMismatchException
Modifier
Constructor
Description
``
`EnumeratedIntegerDistribution(int[] singletons, double[] probabilities)`
Create a discrete distribution using the given probability mass function definition.
``
`EnumeratedIntegerDistribution(RandomGenerator rng, int[] singletons, double[] probabilities)`
Create a discrete distribution using the given random number generator and probability mass function definition.
``
`EnumeratedRealDistribution(double[] singletons, double[] probabilities)`
Create a discrete real-valued distribution using the given probability mass function enumeration.
``
`EnumeratedRealDistribution(RandomGenerator rng, double[] singletons, double[] probabilities)`
Create a discrete real-valued distribution using the given random number generator and probability mass function enumeration.
``
`MixtureMultivariateNormalDistribution(RandomGenerator rng, List<Pair<Double,MultivariateNormalDistribution>> components)`
Creates a mixture model from a list of distributions and their associated weights.
``
`MultivariateNormalDistribution(double[] means, double[][] covariances)`
Creates a multivariate normal distribution with the given mean vector and covariance matrix.
``
`MultivariateNormalDistribution(RandomGenerator rng, double[] means, double[][] covariances)`
Creates a multivariate normal distribution with the given mean vector and covariance matrix.

## Uses of DimensionMismatchException in org.apache.commons.math3.distribution.fitting

Methods in org.apache.commons.math3.distribution.fitting that throw DimensionMismatchException
Modifier and Type
Method
Description
`static MixtureMultivariateNormalDistribution`
MultivariateNormalMixtureExpectationMaximization.`estimate(double[][] data, int numComponents)`
Helper method to create a multivariate normal mixture model which can be used to initialize `MultivariateNormalMixtureExpectationMaximization.fit(MixtureMultivariateNormalDistribution)`.
`void`
MultivariateNormalMixtureExpectationMaximization.`fit(MixtureMultivariateNormalDistribution initialMixture, int maxIterations, double threshold)`
Fit a mixture model to the data supplied to the constructor.
Constructors in org.apache.commons.math3.distribution.fitting that throw DimensionMismatchException
Modifier
Constructor
Description
``
`MultivariateNormalMixtureExpectationMaximization(double[][] data)`
Creates an object to fit a multivariate normal mixture model to data.

## Uses of DimensionMismatchException in org.apache.commons.math3.filter

Methods in org.apache.commons.math3.filter that throw DimensionMismatchException
Modifier and Type
Method
Description
`void`
KalmanFilter.`correct(double[] z)`
Correct the current state estimate with an actual measurement.
`void`
KalmanFilter.`correct(RealVector z)`
Correct the current state estimate with an actual measurement.
`void`
KalmanFilter.`predict(double[] u)`
Predict the internal state estimation one time step ahead.
`void`
KalmanFilter.`predict(RealVector u)`
Predict the internal state estimation one time step ahead.
Constructors in org.apache.commons.math3.filter that throw DimensionMismatchException
Modifier
Constructor
Description
``
`DefaultMeasurementModel(double[][] measMatrix, double[][] measNoise)`
Create a new `MeasurementModel`, taking double arrays as input parameters for the respective measurement matrix and noise.
``
`DefaultProcessModel(double[][] stateTransition, double[][] control, double[][] processNoise)`
Create a new `ProcessModel`, taking double arrays as input parameters.
``
`DefaultProcessModel(double[][] stateTransition, double[][] control, double[][] processNoise, double[] initialStateEstimate, double[][] initialErrorCovariance)`
Create a new `ProcessModel`, taking double arrays as input parameters.
``
`KalmanFilter(ProcessModel process, MeasurementModel measurement)`
Creates a new Kalman filter with the given process and measurement models.

## Uses of DimensionMismatchException in org.apache.commons.math3.genetics

Methods in org.apache.commons.math3.genetics that throw DimensionMismatchException
Modifier and Type
Method
Description
`ChromosomePair`
CycleCrossover.`crossover(Chromosome first, Chromosome second)`
Perform a crossover operation on the given chromosomes.
`ChromosomePair`
NPointCrossover.`crossover(Chromosome first, Chromosome second)`
Performs a N-point crossover.
`ChromosomePair`
OnePointCrossover.`crossover(Chromosome first, Chromosome second)`
Performs one point crossover.
`ChromosomePair`
OrderedCrossover.`crossover(Chromosome first, Chromosome second)`
Perform a crossover operation on the given chromosomes.
`ChromosomePair`
UniformCrossover.`crossover(Chromosome first, Chromosome second)`
Perform a crossover operation on the given chromosomes.
`static <S> List<Double>`
RandomKey.`inducedPermutation(List<S> originalData, List<S> permutedData)`
Generates a representation of a permutation corresponding to a permutation which yields `permutedData` when applied to `originalData`.
`protected ChromosomePair`
CycleCrossover.`mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)`
Helper for `CycleCrossover.crossover(Chromosome, Chromosome)`.
`protected ChromosomePair`
OrderedCrossover.`mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)`
Helper for `OrderedCrossover.crossover(Chromosome, Chromosome)`.

## Uses of DimensionMismatchException in org.apache.commons.math3.geometry.euclidean.threed

Constructors in org.apache.commons.math3.geometry.euclidean.threed that throw DimensionMismatchException
Modifier
Constructor
Description
``
`FieldVector3D(T[] v)`
Simple constructor.
``
`Vector3D(double[] v)`
Simple constructor.

## Uses of DimensionMismatchException in org.apache.commons.math3.geometry.euclidean.twod

Constructors in org.apache.commons.math3.geometry.euclidean.twod that throw DimensionMismatchException
Modifier
Constructor
Description
``
`Vector2D(double[] v)`
Simple constructor.

## Uses of DimensionMismatchException in org.apache.commons.math3.linear

Subclasses of DimensionMismatchException in org.apache.commons.math3.linear
Modifier and Type
Class
Description
`class`
`NonSquareMatrixException`
Exception to be thrown when a square matrix is expected.
`class`
`NonSquareOperatorException`
Exception to be thrown when a square linear operator is expected.
Methods in org.apache.commons.math3.linear that throw DimensionMismatchException
Modifier and Type
Method
Description
`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`.
`FieldVector<T>`
FieldVector.`add(FieldVector<T> v)`
Compute the sum of `this` and `v`.
`OpenMapRealVector`
OpenMapRealVector.`add(OpenMapRealVector v)`
Optimized method to add two OpenMapRealVectors.
`RealVector`
OpenMapRealVector.`add(RealVector v)`
Compute the sum of this vector and `v`.
`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.
`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`
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`.
`double`
RealVector.`cosine(RealVector v)`
Computes the cosine of the angle between this vector and the argument.
`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.
`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.
`static RealMatrix`
MatrixUtils.`createRealMatrix(double[][] data)`
Returns a `RealMatrix` whose entries are the the values in the the input array.
`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`
OpenMapRealVector.`dotProduct(OpenMapRealVector v)`
Deprecated.
as of 3.1 (to be removed in 4.0).
`double`
RealVector.`dotProduct(RealVector v)`
Compute the dot product of this vector with `v`.
`T`
SparseFieldVector.`dotProduct(FieldVector<T> v)`
Compute the dot product.
`ArrayFieldVector<T>`
ArrayFieldVector.`ebeDivide(ArrayFieldVector<T> v)`
Element-by-element division.
`FieldVector<T>`
ArrayFieldVector.`ebeDivide(FieldVector<T> v)`
Element-by-element division.
`ArrayRealVector`
ArrayRealVector.`ebeDivide(RealVector v)`
Element-by-element division.
`FieldVector<T>`
FieldVector.`ebeDivide(FieldVector<T> v)`
Element-by-element division.
`OpenMapRealVector`
OpenMapRealVector.`ebeDivide(RealVector v)`
Element-by-element division.
`abstract RealVector`
RealVector.`ebeDivide(RealVector v)`
Element-by-element division.
`FieldVector<T>`
SparseFieldVector.`ebeDivide(FieldVector<T> v)`
Element-by-element division.
`ArrayFieldVector<T>`
ArrayFieldVector.`ebeMultiply(ArrayFieldVector<T> v)`
Element-by-element multiplication.
`FieldVector<T>`
ArrayFieldVector.`ebeMultiply(FieldVector<T> v)`
Element-by-element multiplication.
`ArrayRealVector`
ArrayRealVector.`ebeMultiply(RealVector v)`
Element-by-element multiplication.
`FieldVector<T>`
FieldVector.`ebeMultiply(FieldVector<T> v)`
Element-by-element multiplication.
`OpenMapRealVector`
OpenMapRealVector.`ebeMultiply(RealVector v)`
Element-by-element multiplication.
`abstract RealVector`
RealVector.`ebeMultiply(RealVector v)`
Element-by-element multiplication.
`FieldVector<T>`
SparseFieldVector.`ebeMultiply(FieldVector<T> v)`
Element-by-element multiplication.
`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.
`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.
`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`.
`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 `x`.
`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`.
`abstract 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`.
`RealVector`
RealLinearOperator.`operateTranspose(RealVector x)`
Returns the result of multiplying the transpose of `this` operator by the vector `x` (optional operation).
`FieldMatrix<T>`
AbstractFieldMatrix.`preMultiply(FieldMatrix<T> m)`
Premultiply this matrix by `m`.
`FieldVector<T>`
AbstractFieldMatrix.`preMultiply(FieldVector<T> v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`
AbstractFieldMatrix.`preMultiply(T[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`
AbstractRealMatrix.`preMultiply(double[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`RealMatrix`
AbstractRealMatrix.`preMultiply(RealMatrix m)`
Returns the result of premultiplying `this` by `m`.
`RealVector`
AbstractRealMatrix.`preMultiply(RealVector v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`
Array2DRowFieldMatrix.`preMultiply(T[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`
Array2DRowRealMatrix.`preMultiply(double[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`
BlockFieldMatrix.`preMultiply(T[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`
BlockRealMatrix.`preMultiply(double[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`
DiagonalMatrix.`preMultiply(double[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`RealVector`
DiagonalMatrix.`preMultiply(RealVector v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`FieldMatrix<T>`
FieldMatrix.`preMultiply(FieldMatrix<T> m)`
Premultiply this matrix by `m`.
`FieldVector<T>`
FieldMatrix.`preMultiply(FieldVector<T> v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`T[]`
FieldMatrix.`preMultiply(T[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`double[]`
RealMatrix.`preMultiply(double[] v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`RealMatrix`
RealMatrix.`preMultiply(RealMatrix m)`
Returns the result of premultiplying `this` by `m`.
`RealVector`
RealMatrix.`preMultiply(RealVector v)`
Returns the (row) vector result of premultiplying this by the vector `v`.
`ArrayFieldVector<T>`
ArrayFieldVector.`projection(ArrayFieldVector<T> v)`
Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`
ArrayFieldVector.`projection(FieldVector<T> v)`
Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`
FieldVector.`projection(FieldVector<T> v)`
Find the orthogonal projection of this vector onto another vector.
`RealVector`
RealVector.`projection(RealVector v)`
Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>`
SparseFieldVector.`projection(FieldVector<T> v)`
Find the orthogonal projection of this vector onto another vector.
`void`
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.
`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`.
`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.
`FieldVector<T>`
FieldVector.`subtract(FieldVector<T> v)`
Compute `this` minus `v`.
`OpenMapRealVector`
OpenMapRealVector.`subtract(OpenMapRealVector v)`
Optimized method to subtract OpenMapRealVectors.
`RealVector`
OpenMapRealVector.`subtract(RealVector v)`
Subtract `v` from this vector.
`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.
Constructors in org.apache.commons.math3.linear that throw DimensionMismatchException
Modifier
Constructor
Description
``
`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[][] 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.
``
`BlockFieldMatrix(int rows, int columns, T[][] blockData, boolean copyArray)`
Create a new dense matrix copying entries from block layout data.
``
`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, double[][] blockData, boolean copyArray)`
Create a new dense matrix copying entries from block layout data.

## Uses of DimensionMismatchException in org.apache.commons.math3.ml.distance

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

## Uses of DimensionMismatchException in org.apache.commons.math3.ode

Methods in org.apache.commons.math3.ode that throw DimensionMismatchException
Modifier and Type
Method
Description
`protected FieldODEStateAndDerivative<T>`
AbstractFieldIntegrator.`acceptStep(AbstractFieldStepInterpolator<T> interpolator, T tEnd)`
Accept a step, triggering events and step handlers.
`protected double`
AbstractIntegrator.`acceptStep(AbstractStepInterpolator interpolator, double[] y, double[] yDot, double tEnd)`
Accept a step, triggering events and step handlers.
`T[]`
AbstractFieldIntegrator.`computeDerivatives(T t, T[] y)`
Compute the derivatives and check the number of evaluations.
`void`
AbstractIntegrator.`computeDerivatives(double t, double[] y, double[] yDot)`
Compute the derivatives and check the number of evaluations.
`void`
ExpandableStatefulODE.`computeDerivatives(double t, double[] y, double[] yDot)`
Get the current time derivative of the complete state vector.
`T[]`
FieldExpandableODE.`computeDerivatives(T t, T[] y)`
Get the current time derivative of the complete state vector.
`T[]`
FieldSecondaryEquations.`computeDerivatives(T t, T[] primary, T[] primaryDot, T[] secondary)`
Compute the derivatives related to the secondary state parameters.
`void`
FirstOrderDifferentialEquations.`computeDerivatives(double t, double[] y, double[] yDot)`
Get the current time derivative of the state vector.
`void`
SecondaryEquations.`computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary, double[] secondaryDot)`
Compute the derivatives related to the secondary state parameters.
`void`
MainStateJacobianProvider.`computeMainStateJacobian(double t, double[] y, double[] yDot, double[][] dFdY)`
Compute the jacobian matrix of ODE with respect to main state.
`void`
ParameterJacobianProvider.`computeParameterJacobian(double t, double[] y, double[] yDot, String paramName, double[] dFdP)`
Compute the Jacobian matrix of ODE with respect to one parameter.
`void`
EquationsMapper.`extractEquationData(double[] complete, double[] equationData)`
Extract equation data from a complete state or derivative array.
`T[]`
FieldEquationsMapper.`extractEquationData(int index, T[] complete)`
Extract equation data from a complete state or derivative array.
`double[]`
ExpandableStatefulODE.`getCompleteState()`
Get the complete current state.
`void`
EquationsMapper.`insertEquationData(double[] equationData, double[] complete)`
Insert equation data into a complete state or derivative array.
`void`
FieldEquationsMapper.`insertEquationData(int index, T[] equationData, T[] complete)`
Insert equation data into a complete state or derivative array.
`abstract void`
AbstractIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`double`
AbstractIntegrator.`integrate(FirstOrderDifferentialEquations equations, double t0, double[] y0, double t, double[] y)`
Integrate the differential equations up to the given time.
`double`
FirstOrderIntegrator.`integrate(FirstOrderDifferentialEquations equations, double t0, double[] y0, double t, double[] y)`
Integrate the differential equations up to the given time.
`FieldODEStateAndDerivative<T>`
FieldEquationsMapper.`mapStateAndDerivative(T t, T[] y, T[] yDot)`
Map flat arrays to a state and derivative.
`void`
JacobianMatrices.`registerVariationalEquations(ExpandableStatefulODE expandable)`
Register the variational equations for the Jacobians matrices to the expandable set.
`protected void`
AbstractFieldIntegrator.`sanityChecks(FieldODEState<T> eqn, T t)`
Check the integration span.
`protected void`
AbstractIntegrator.`sanityChecks(ExpandableStatefulODE equations, double t)`
Check the integration span.
`void`
ExpandableStatefulODE.`setCompleteState(double[] completeState)`
Set the complete current state.
`void`
JacobianMatrices.`setInitialMainStateJacobian(double[][] dYdY0)`
Set the initial value of the Jacobian matrix with respect to state.
`void`
JacobianMatrices.`setInitialParameterJacobian(String pName, double[] dYdP)`
Set the initial value of a column of the Jacobian matrix with respect to one parameter.
`void`
ExpandableStatefulODE.`setPrimaryState(double[] primaryState)`
Set primary part of the current state.
`void`
ExpandableStatefulODE.`setSecondaryState(int index, double[] secondaryState)`
Set secondary part of the current state.
`protected void`
MultistepFieldIntegrator.`start(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T t)`
Start the integration.
`protected void`
MultistepIntegrator.`start(double t0, double[] y0, double t)`
Start the integration.
Constructors in org.apache.commons.math3.ode that throw DimensionMismatchException
Modifier
Constructor
Description
``
`JacobianMatrices(FirstOrderDifferentialEquations fode, double[] hY, String... parameters)`
Simple constructor for a secondary equations set computing Jacobian matrices.

## Uses of DimensionMismatchException in org.apache.commons.math3.ode.nonstiff

Methods in org.apache.commons.math3.ode.nonstiff that throw DimensionMismatchException
Modifier and Type
Method
Description
`T`
AdaptiveStepsizeFieldIntegrator.`initializeStep(boolean forward, int order, T[] scale, FieldODEStateAndDerivative<T> state0, FieldEquationsMapper<T> mapper)`
Initialize the integration step.
`double`
AdaptiveStepsizeIntegrator.`initializeStep(boolean forward, int order, double[] scale, double t0, double[] y0, double[] yDot0, double[] y1, double[] yDot1)`
Initialize the integration step.
`FieldODEStateAndDerivative<T>`
AdamsBashforthFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`
Integrate the differential equations up to the given time.
`void`
AdamsBashforthIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`abstract FieldODEStateAndDerivative<T>`
AdamsFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`
Integrate the differential equations up to the given time.
`abstract void`
AdamsIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`FieldODEStateAndDerivative<T>`
AdamsMoultonFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`
Integrate the differential equations up to the given time.
`void`
AdamsMoultonIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`abstract void`
AdaptiveStepsizeIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`FieldODEStateAndDerivative<T>`
EmbeddedRungeKuttaFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`
Integrate the differential equations up to the given time.
`void`
EmbeddedRungeKuttaIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`void`
GraggBulirschStoerIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`FieldODEStateAndDerivative<T>`
RungeKuttaFieldIntegrator.`integrate(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T finalTime)`
Integrate the differential equations up to the given time.
`void`
RungeKuttaIntegrator.`integrate(ExpandableStatefulODE equations, double t)`
Integrate a set of differential equations up to the given time.
`protected void`
AdaptiveStepsizeFieldIntegrator.`sanityChecks(FieldODEState<T> eqn, T t)`
Check the integration span.
`protected void`
AdaptiveStepsizeIntegrator.`sanityChecks(ExpandableStatefulODE equations, double t)`
Check the integration span.

## Uses of DimensionMismatchException in org.apache.commons.math3.optim.nonlinear.scalar.noderiv

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

## Uses of DimensionMismatchException in org.apache.commons.math3.optim.nonlinear.vector

Methods in org.apache.commons.math3.optim.nonlinear.vector that throw DimensionMismatchException
Modifier and Type
Method
Description
`PointVectorValuePair`
JacobianMultivariateVectorOptimizer.`optimize(OptimizationData... optData)`
Deprecated.
Stores data and performs the optimization.
`PointVectorValuePair`
MultivariateVectorOptimizer.`optimize(OptimizationData... optData)`
Deprecated.
Stores data and performs the optimization.

## Uses of DimensionMismatchException in org.apache.commons.math3.optimization.direct

Methods in org.apache.commons.math3.optimization.direct that throw DimensionMismatchException
Modifier and Type
Method
Description
`protected PointVectorValuePair`
BaseAbstractMultivariateVectorOptimizer.`optimize(int maxEval, FUNC f, OptimizationData... optData)`
Deprecated.
Optimize an objective function.
`protected PointVectorValuePair`
BaseAbstractMultivariateVectorOptimizer.`optimizeInternal(int maxEval, FUNC f, OptimizationData... optData)`
Deprecated.
Optimize an objective function.

## Uses of DimensionMismatchException in org.apache.commons.math3.random

Constructors in org.apache.commons.math3.random that throw DimensionMismatchException
Modifier
Constructor
Description
``
`HaltonSequenceGenerator(int dimension, int[] bases, int[] weights)`
Construct a new Halton sequence generator with the given base numbers and weights for each dimension.

## Uses of DimensionMismatchException in org.apache.commons.math3.stat

Methods in org.apache.commons.math3.stat that throw DimensionMismatchException
Modifier and Type
Method
Description
`static double`
StatUtils.`meanDifference(double[] sample1, double[] sample2)`
Returns the mean of the (signed) differences between corresponding elements of the input arrays -- i.e., sum(sample1[i] - sample2[i]) / sample1.length.
`static double`
StatUtils.`sumDifference(double[] sample1, double[] sample2)`
Returns the sum of the (signed) differences between corresponding elements of the input arrays -- i.e., sum(sample1[i] - sample2[i]).
`static double`
StatUtils.`varianceDifference(double[] sample1, double[] sample2, double meanDifference)`
Returns the variance of the (signed) differences between corresponding elements of the input arrays -- i.e., var(sample1[i] - sample2[i]).

## Uses of DimensionMismatchException in org.apache.commons.math3.stat.correlation

Methods in org.apache.commons.math3.stat.correlation that throw DimensionMismatchException
Modifier and Type
Method
Description
`void`
StorelessCovariance.`append(StorelessCovariance sc)`
Appends `sc` to this, effectively aggregating the computations in `sc` with this.
`double`
KendallsCorrelation.`correlation(double[] xArray, double[] yArray)`
Computes the Kendall's Tau rank correlation coefficient between the two arrays.
`void`
StorelessCovariance.`increment(double[] data)`
Increment the covariance matrix with one row of data.

## Uses of DimensionMismatchException in org.apache.commons.math3.stat.descriptive

Methods in org.apache.commons.math3.stat.descriptive that throw DimensionMismatchException
Modifier and Type
Method
Description
`void`
MultivariateSummaryStatistics.`addValue(double[] value)`
Add an n-tuple to the data
`void`
SynchronizedMultivariateSummaryStatistics.`addValue(double[] value)`
Add an n-tuple to the data
`void`
MultivariateSummaryStatistics.`setGeoMeanImpl(StorelessUnivariateStatistic[] geoMeanImpl)`
Sets the implementation for the geometric mean.
`void`
SynchronizedMultivariateSummaryStatistics.`setGeoMeanImpl(StorelessUnivariateStatistic[] geoMeanImpl)`
Sets the implementation for the geometric mean.
`void`
MultivariateSummaryStatistics.`setMaxImpl(StorelessUnivariateStatistic[] maxImpl)`
Sets the implementation for the maximum.
`void`
SynchronizedMultivariateSummaryStatistics.`setMaxImpl(StorelessUnivariateStatistic[] maxImpl)`
Sets the implementation for the maximum.
`void`
MultivariateSummaryStatistics.`setMeanImpl(StorelessUnivariateStatistic[] meanImpl)`
Sets the implementation for the mean.
`void`
SynchronizedMultivariateSummaryStatistics.`setMeanImpl(StorelessUnivariateStatistic[] meanImpl)`
Sets the implementation for the mean.
`void`
MultivariateSummaryStatistics.`setMinImpl(StorelessUnivariateStatistic[] minImpl)`
Sets the implementation for the minimum.
`void`
SynchronizedMultivariateSummaryStatistics.`setMinImpl(StorelessUnivariateStatistic[] minImpl)`
Sets the implementation for the minimum.
`void`
MultivariateSummaryStatistics.`setSumImpl(StorelessUnivariateStatistic[] sumImpl)`
Sets the implementation for the Sum.
`void`
SynchronizedMultivariateSummaryStatistics.`setSumImpl(StorelessUnivariateStatistic[] sumImpl)`
Sets the implementation for the Sum.
`void`
MultivariateSummaryStatistics.`setSumLogImpl(StorelessUnivariateStatistic[] sumLogImpl)`
Sets the implementation for the sum of logs.
`void`
SynchronizedMultivariateSummaryStatistics.`setSumLogImpl(StorelessUnivariateStatistic[] sumLogImpl)`
Sets the implementation for the sum of logs.
`void`
MultivariateSummaryStatistics.`setSumsqImpl(StorelessUnivariateStatistic[] sumsqImpl)`
Sets the implementation for the sum of squares.
`void`
SynchronizedMultivariateSummaryStatistics.`setSumsqImpl(StorelessUnivariateStatistic[] sumsqImpl)`
Sets the implementation for the sum of squares.

## Uses of DimensionMismatchException in org.apache.commons.math3.stat.descriptive.moment

Methods in org.apache.commons.math3.stat.descriptive.moment that throw DimensionMismatchException
Modifier and Type
Method
Description
`void`
VectorialCovariance.`increment(double[] v)`
Add a new vector to the sample.
`void`
VectorialMean.`increment(double[] v)`
Add a new vector to the sample.

## Uses of DimensionMismatchException in org.apache.commons.math3.stat.inference

Methods in org.apache.commons.math3.stat.inference that throw DimensionMismatchException
Modifier and Type
Method
Description
`double`
OneWayAnova.`anovaFValue(Collection<double[]> categoryData)`
Computes the ANOVA F-value for a collection of `double[]` arrays.
`double`
OneWayAnova.`anovaPValue(Collection<double[]> categoryData)`
Computes the ANOVA P-value for a collection of `double[]` arrays.
`double`
OneWayAnova.`anovaPValue(Collection<SummaryStatistics> categoryData, boolean allowOneElementData)`
Computes the ANOVA P-value for a collection of `SummaryStatistics`.
`boolean`
OneWayAnova.`anovaTest(Collection<double[]> categoryData, double alpha)`
Performs an ANOVA test, evaluating the null hypothesis that there is no difference among the means of the data categories.
`double`
ChiSquareTest.`chiSquare(double[] expected, long[] observed)`
Computes the Chi-Square statistic comparing `observed` and `expected` frequency counts.
`double`
ChiSquareTest.`chiSquare(long[][] counts)`
Computes the Chi-Square statistic associated with a chi-square test of independence based on the input `counts` array, viewed as a two-way table.
`static double`
TestUtils.`chiSquare(double[] expected, long[] observed)`
`static double`
TestUtils.`chiSquare(long[][] counts)`
`double`
ChiSquareTest.`chiSquareDataSetsComparison(long[] observed1, long[] observed2)`
Computes a Chi-Square two sample test statistic comparing bin frequency counts in `observed1` and `observed2`.
`static double`
TestUtils.`chiSquareDataSetsComparison(long[] observed1, long[] observed2)`
`double`
ChiSquareTest.`chiSquareTest(double[] expected, long[] observed)`
Returns the observed significance level, or p-value, associated with a Chi-square goodness of fit test comparing the `observed` frequency counts to those in the `expected` array.
`boolean`
ChiSquareTest.`chiSquareTest(double[] expected, long[] observed, double alpha)`
Performs a Chi-square goodness of fit test evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level `alpha`.
`double`
ChiSquareTest.`chiSquareTest(long[][] counts)`
Returns the observed significance level, or p-value, associated with a chi-square test of independence based on the input `counts` array, viewed as a two-way table.
`boolean`
ChiSquareTest.`chiSquareTest(long[][] counts, double alpha)`
Performs a chi-square test of independence evaluating the null hypothesis that the classifications represented by the counts in the columns of the input 2-way table are independent of the rows, with significance level `alpha`.
`static double`
TestUtils.`chiSquareTest(double[] expected, long[] observed)`
`static boolean`
TestUtils.`chiSquareTest(double[] expected, long[] observed, double alpha)`
`static double`
TestUtils.`chiSquareTest(long[][] counts)`
`static boolean`
TestUtils.`chiSquareTest(long[][] counts, double alpha)`
`double`
ChiSquareTest.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)`
Returns the observed significance level, or p-value, associated with a Chi-Square two sample test comparing bin frequency counts in `observed1` and `observed2`.
`boolean`
ChiSquareTest.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
Performs a Chi-Square two sample test comparing two binned data sets.
`static double`
TestUtils.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)`
`static boolean`
TestUtils.`chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
`double`
GTest.`g(double[] expected, long[] observed)`
Computes the G statistic for Goodness of Fit comparing `observed` and `expected` frequency counts.
`static double`
TestUtils.`g(double[] expected, long[] observed)`
`double`
GTest.`gDataSetsComparison(long[] observed1, long[] observed2)`
Computes a G (Log-Likelihood Ratio) two sample test statistic for independence comparing frequency counts in `observed1` and `observed2`.
`static double`
TestUtils.`gDataSetsComparison(long[] observed1, long[] observed2)`
`double`
GTest.`gTest(double[] expected, long[] observed)`
Returns the observed significance level, or p-value, associated with a G-Test for goodness of fit comparing the `observed` frequency counts to those in the `expected` array.
`boolean`
GTest.`gTest(double[] expected, long[] observed, double alpha)`
Performs a G-Test (Log-Likelihood Ratio Test) for goodness of fit evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level `alpha`.
`static double`
TestUtils.`gTest(double[] expected, long[] observed)`
`static boolean`
TestUtils.`gTest(double[] expected, long[] observed, double alpha)`
`double`
GTest.`gTestDataSetsComparison(long[] observed1, long[] observed2)`
Returns the observed significance level, or p-value, associated with a G-Value (Log-Likelihood Ratio) for two sample test comparing bin frequency counts in `observed1` and `observed2`.
`boolean`
GTest.`gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
Performs a G-Test (Log-Likelihood Ratio Test) comparing two binned data sets.
`static double`
TestUtils.`gTestDataSetsComparison(long[] observed1, long[] observed2)`
`static boolean`
TestUtils.`gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)`
`double`
GTest.`gTestIntrinsic(double[] expected, long[] observed)`
Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described in p64-69 of McDonald, J.H.
`static double`
TestUtils.`gTestIntrinsic(double[] expected, long[] observed)`
`static double`
TestUtils.`oneWayAnovaFValue(Collection<double[]> categoryData)`
`static double`
TestUtils.`oneWayAnovaPValue(Collection<double[]> categoryData)`
`static boolean`
TestUtils.`oneWayAnovaTest(Collection<double[]> categoryData, double alpha)`
`static double`
TestUtils.`pairedT(double[] sample1, double[] sample2)`
`double`
TTest.`pairedT(double[] sample1, double[] sample2)`
Computes a paired, 2-sample t-statistic based on the data in the input arrays.
`static double`
TestUtils.`pairedTTest(double[] sample1, double[] sample2)`
`static boolean`
TestUtils.`pairedTTest(double[] sample1, double[] sample2, double alpha)`
`double`
TTest.`pairedTTest(double[] sample1, double[] sample2)`
Returns the observed significance level, or p-value, associated with a paired, two-sample, two-tailed t-test based on the data in the input arrays.
`boolean`
TTest.`pairedTTest(double[] sample1, double[] sample2, double alpha)`
Performs a paired t-test evaluating the null hypothesis that the mean of the paired differences between `sample1` and `sample2` is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0, with significance level `alpha`.
`static double`
TestUtils.`rootLogLikelihoodRatio(long k11, long k12, long k21, long k22)`
`double`
WilcoxonSignedRankTest.`wilcoxonSignedRank(double[] x, double[] y)`
Computes the Wilcoxon signed ranked statistic comparing mean for two related samples or repeated measurements on a single sample.
`double`
WilcoxonSignedRankTest.`wilcoxonSignedRankTest(double[] x, double[] y, boolean exactPValue)`
Returns the observed significance level, or p-value, associated with a Wilcoxon signed ranked statistic comparing mean for two related samples or repeated measurements on a single sample.

## Uses of DimensionMismatchException in org.apache.commons.math3.transform

Methods in org.apache.commons.math3.transform that throw DimensionMismatchException
Modifier and Type
Method
Description
`static Complex[]`
TransformUtils.`createComplexArray(double[][] dataRI)`
Builds a new array of `Complex` from the specified two dimensional array of real and imaginary parts.

## Uses of DimensionMismatchException in org.apache.commons.math3.util

Methods in org.apache.commons.math3.util that throw DimensionMismatchException
Modifier and Type
Method
Description
`static void`
MathArrays.`checkRectangular(long[][] in)`
Throws DimensionMismatchException if the input array is not rectangular.
`static double`
MathArrays.`distance(double[] p1, double[] p2)`
Calculates the L2 (Euclidean) distance between two points.
`static double`
MathArrays.`distance(int[] p1, int[] p2)`
Calculates the L2 (Euclidean) distance between two points.
`static double`
MathArrays.`distance1(double[] p1, double[] p2)`
Calculates the L1 (sum of abs) distance between two points.
`static int`
MathArrays.`distance1(int[] p1, int[] p2)`
Calculates the L1 (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.
`int`
MultidimensionalCounter.`getCount(int... c)`
Convert to unidimensional counter.
`Decimal64`
Decimal64.`linearCombination(double[] a, Decimal64[] b)`
Compute a linear combination.
`Decimal64`
Decimal64.`linearCombination(Decimal64[] a, Decimal64[] b)`
Compute a linear combination.
`static double`
MathArrays.`linearCombination(double[] a, double[] b)`
Compute a linear combination accurately.
`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.