## Uses of Classorg.apache.commons.math4.exception.DimensionMismatchException

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

Methods in org.apache.commons.math4 that throw DimensionMismatchException
Modifier and Type Method and 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.math4.analysis.differentiation

Methods in org.apache.commons.math4.analysis.differentiation that throw DimensionMismatchException
Modifier and Type Method and 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(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.
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.
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.math4.analysis.differentiation that throw DimensionMismatchException
Constructor and 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.math4.analysis.function

Methods in org.apache.commons.math4.analysis.function that throw DimensionMismatchException
Modifier and Type Method and Description
double[] Logistic.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.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[] Logit.Parametric.gradient(double x, double... param)
Computes the value of the gradient at x.
DerivativeStructure Sigmoid.value(DerivativeStructure t)
Simple mathematical function.
DerivativeStructure Gaussian.value(DerivativeStructure t)
Simple mathematical function.
DerivativeStructure HarmonicOscillator.value(DerivativeStructure t)
Simple mathematical function.
DerivativeStructure Sinc.value(DerivativeStructure t)
Simple mathematical function.
double Logistic.Parametric.value(double x, double... param)
Computes the value of the sigmoid at x.
double Sigmoid.Parametric.value(double x, double... param)
Computes the value of the sigmoid at x.
double Gaussian.Parametric.value(double x, double... param)
Computes the value of the Gaussian at x.
double HarmonicOscillator.Parametric.value(double x, double... param)
Computes the value of the harmonic oscillator at x.
double Logit.Parametric.value(double x, double... param)
Computes the value of the logit at x.
Constructors in org.apache.commons.math4.analysis.function that throw DimensionMismatchException
Constructor and 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.math4.analysis.interpolation

Methods in org.apache.commons.math4.analysis.interpolation that throw DimensionMismatchException
Modifier and Type Method and Description
void FieldHermiteInterpolator.addSamplePoint(T x, T[]... value)
protected static double[] DividedDifferenceInterpolator.computeDividedDifference(double[] x, double[] y)
Return a copy of the divided difference array.
MultivariateFunction MultivariateInterpolator.interpolate(double[][] xval, double[] yval)
Computes an interpolating function for the data set.
MultivariateFunction MicrosphereProjectionInterpolator.interpolate(double[][] xval, double[] yval)
Computes an interpolating function for the data set.
UnivariateFunction UnivariateInterpolator.interpolate(double[] xval, double[] yval)
Compute an interpolating function for the dataset.
PolynomialFunctionNewtonForm DividedDifferenceInterpolator.interpolate(double[] x, double[] y)
Compute an interpolating function for the dataset.
PolynomialSplineFunction SplineInterpolator.interpolate(double[] x, double[] y)
Computes an interpolating function for the data set.
PolynomialFunctionLagrangeForm NevilleInterpolator.interpolate(double[] x, double[] y)
Computes an interpolating function for the data set.
PolynomialSplineFunction LinearInterpolator.interpolate(double[] x, double[] y)
Computes a linear interpolating function for the data set.
PolynomialSplineFunction AkimaSplineInterpolator.interpolate(double[] xvals, double[] yvals)
Computes an 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.
PiecewiseBicubicSplineInterpolatingFunction PiecewiseBicubicSplineInterpolator.interpolate(double[] xval, double[] yval, double[][] fval)
Compute an interpolating function for the dataset.
BicubicInterpolatingFunction BicubicInterpolator.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.
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.
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.
Constructors in org.apache.commons.math4.analysis.interpolation that throw DimensionMismatchException
Constructor and Description
BicubicInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)
PiecewiseBicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f)
TricubicInterpolatingFunction(double[] x, double[] y, double[] z, double[][][] f, double[][][] dFdX, double[][][] dFdY, double[][][] dFdZ, double[][][] d2FdXdY, double[][][] d2FdXdZ, double[][][] d2FdYdZ, double[][][] d3FdXdYdZ)
• ### Uses of DimensionMismatchException in org.apache.commons.math4.analysis.polynomials

Methods in org.apache.commons.math4.analysis.polynomials that throw DimensionMismatchException
Modifier and Type Method and Description
static double PolynomialFunctionNewtonForm.evaluate(double[] a, double[] c, double z)
Evaluate the Newton polynomial using nested multiplication.
static double PolynomialFunctionLagrangeForm.evaluate(double[] x, double[] y, double z)
Evaluate the Lagrange polynomial using Neville's Algorithm.
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.math4.analysis.polynomials that throw DimensionMismatchException
Constructor and 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.math4.dfp

Methods in org.apache.commons.math4.dfp that throw DimensionMismatchException
Modifier and Type Method and Description
Dfp Dfp.atan2(Dfp x)
Two arguments arc tangent operation.
Dfp Dfp.linearCombination(Dfp[] a, Dfp[] b)
Compute a linear combination.
Dfp Dfp.linearCombination(double[] a, Dfp[] b)
Compute a linear combination.
• ### Uses of DimensionMismatchException in org.apache.commons.math4.distribution

Methods in org.apache.commons.math4.distribution that throw DimensionMismatchException
Modifier and Type Method and 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.math4.distribution that throw DimensionMismatchException
Constructor and Description
EnumeratedIntegerDistribution(int[] singletons, double[] probabilities)
Create a discrete distribution.
EnumeratedRealDistribution(double[] singletons, double[] probabilities)
Create a discrete real-valued distribution using the given random number generator and probability mass function enumeration.
MixtureMultivariateNormalDistribution(double[] weights, double[][] means, double[][][] covariances)
Creates a multivariate normal mixture distribution.
MixtureMultivariateNormalDistribution(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.
• ### Uses of DimensionMismatchException in org.apache.commons.math4.distribution.fitting

Methods in org.apache.commons.math4.distribution.fitting that throw DimensionMismatchException
Modifier and Type Method and 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.math4.distribution.fitting that throw DimensionMismatchException
Constructor and Description
MultivariateNormalMixtureExpectationMaximization(double[][] data)
Creates an object to fit a multivariate normal mixture model to data.
• ### Uses of DimensionMismatchException in org.apache.commons.math4.filter

Methods in org.apache.commons.math4.filter that throw DimensionMismatchException
Modifier and Type Method and 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.math4.filter that throw DimensionMismatchException
Constructor and 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.math4.genetics

Methods in org.apache.commons.math4.genetics that throw DimensionMismatchException
Modifier and Type Method and Description
ChromosomePair OnePointCrossover.crossover(Chromosome first, Chromosome second)
Performs one point crossover.
ChromosomePair UniformCrossover.crossover(Chromosome first, Chromosome second)
Perform a crossover operation on the given chromosomes.
ChromosomePair OrderedCrossover.crossover(Chromosome first, Chromosome second)
Perform a crossover operation on the given chromosomes.
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.
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 OrderedCrossover.mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)
protected ChromosomePair CycleCrossover.mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)
• ### Uses of DimensionMismatchException in org.apache.commons.math4.linear

Subclasses of DimensionMismatchException in org.apache.commons.math4.linear
Modifier and Type Class and 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.math4.linear that throw DimensionMismatchException
Modifier and Type Method and 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.
FieldVector<T> FieldVector.add(FieldVector<T> v)
Compute the sum of this and v.
FieldVector<T> SparseFieldVector.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.
ArrayRealVector ArrayRealVector.add(RealVector v)
Compute the sum of this vector and v.
FieldVector<T> SparseFieldVector.add(SparseFieldVector<T> v)
Optimized method to add sparse vectors.
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 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 void ArrayFieldVector.checkVectorDimensions(FieldVector<T> v)
Check if instance and specified vectors have the same dimension.
protected void ArrayFieldVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
protected void RealVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
protected void SparseFieldVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
protected void ArrayRealVector.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 ArrayRealVector.checkVectorDimensions(RealVector v)
Check if instance and specified vectors have the same dimension.
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.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.combineToSelf(double a, double b, RealVector y)
Updates this with 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.
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 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 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.
T FieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
T SparseFieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
double RealVector.dotProduct(RealVector v)
Compute the dot product of this vector with v.
double ArrayRealVector.dotProduct(RealVector v)
Compute the dot product of this vector with v.
ArrayFieldVector<T> ArrayFieldVector.ebeDivide(ArrayFieldVector<T> v)
Element-by-element division.
FieldVector<T> ArrayFieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
FieldVector<T> FieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
FieldVector<T> SparseFieldVector.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.
ArrayRealVector ArrayRealVector.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.
FieldVector<T> FieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
FieldVector<T> SparseFieldVector.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.
ArrayRealVector ArrayRealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
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.getDistance(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.getL1Distance(RealVector v)
Distance between two vectors.
double OpenMapRealVector.getLInfDistance(RealVector v)
Distance between two vectors.
double RealVector.getLInfDistance(RealVector v)
Distance between two vectors.
double ArrayRealVector.getLInfDistance(RealVector v)
Distance between two vectors.
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.
BlockRealMatrix BlockRealMatrix.multiply(BlockRealMatrix m)
Returns the result of postmultiplying this by m.
DiagonalMatrix DiagonalMatrix.multiply(DiagonalMatrix m)
Returns the result of postmultiplying this by m.
FieldMatrix<T> AbstractFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by m.
FieldMatrix<T> BlockFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix 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 DiagonalMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying this by m.
BlockRealMatrix BlockRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying this by m.
RealMatrix RealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying this by m.
RealMatrix AbstractRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying this by m.
double[] DiagonalMatrix.operate(double[] 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[] Array2DRowRealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector v.
double[] RealMatrix.operate(double[] 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.
FieldVector<T> AbstractFieldMatrix.operate(FieldVector<T> 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.
abstract RealVector RealLinearOperator.operate(RealVector x)
Returns the result of multiplying this by the vector x.
RealVector RealMatrix.operate(RealVector 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[] AbstractFieldMatrix.operate(T[] 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.
T[] FieldMatrix.operate(T[] 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.
RealVector RealLinearOperator.operateTranspose(RealVector x)
Returns the result of multiplying the transpose of this operator by the vector x (optional operation).
double[] DiagonalMatrix.preMultiply(double[] 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[] Array2DRowRealMatrix.preMultiply(double[] 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.
double[] AbstractRealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector v.
FieldMatrix<T> AbstractFieldMatrix.preMultiply(FieldMatrix<T> m)
Premultiply this matrix by m.
FieldMatrix<T> FieldMatrix.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.
FieldVector<T> FieldMatrix.preMultiply(FieldVector<T> 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.
RealMatrix AbstractRealMatrix.preMultiply(RealMatrix m)
Returns the result of premultiplying this by m.
RealVector DiagonalMatrix.preMultiply(RealVector v)
Returns the (row) vector result of premultiplying this by the vector v.
RealVector RealMatrix.preMultiply(RealVector v)
Returns the (row) vector result of premultiplying this by the vector v.
RealVector AbstractRealMatrix.preMultiply(RealVector 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.
T[] BlockFieldMatrix.preMultiply(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.
T[] Array2DRowFieldMatrix.preMultiply(T[] 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.
FieldVector<T> SparseFieldVector.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 BlockRealMatrix.setSubMatrix(double[][] 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 RealMatrix.setSubMatrix(double[][] 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 AbstractFieldMatrix.setSubMatrix(T[][] 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 FieldMatrix.setSubMatrix(T[][] 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.
RealVector PreconditionedIterativeLinearSolver.solve(RealLinearOperator a, RealLinearOperator m, RealVector b)
Returns an estimate of the solution to the linear system A · x = b.
RealVector SymmLQ.solve(RealLinearOperator a, RealLinearOperator m, RealVector b)
Returns an estimate of the solution to the linear system A · x = b.
RealVector SymmLQ.solve(RealLinearOperator a, RealLinearOperator m, RealVector b, boolean goodb, double shift)
Returns an estimate of the solution to the linear system (A - shift · I) · x = b.
RealVector PreconditionedIterativeLinearSolver.solve(RealLinearOperator a, RealLinearOperator m, 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, RealVector x)
Returns an estimate of the solution to the linear system A · x = b.
RealVector IterativeLinearSolver.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)
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 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, RealVector b, RealVector x0)
Returns an estimate of the solution to the linear system A · x = b.
RealVector SymmLQ.solve(RealLinearOperator a, RealVector b, RealVector x)
Returns an estimate of the solution to the linear system A · x = b.
RealVector ConjugateGradient.solveInPlace(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x0)
Returns an estimate of the solution to the linear system A · x = b.
abstract RealVector PreconditionedIterativeLinearSolver.solveInPlace(RealLinearOperator a, RealLinearOperator m, 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.
abstract RealVector IterativeLinearSolver.solveInPlace(RealLinearOperator a, 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, 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.
FieldVector<T> FieldVector.subtract(FieldVector<T> v)
Compute this minus v.
FieldVector<T> SparseFieldVector.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.
ArrayRealVector ArrayRealVector.subtract(RealVector v)
Subtract v from this vector.
SparseFieldVector<T> SparseFieldVector.subtract(SparseFieldVector<T> v)
Optimized method to compute this minus v.
static double[][] BlockRealMatrix.toBlocksLayout(double[][] rawData)
Convert a data array from raw layout to blocks layout.
static <T extends FieldElement<T>>T[][] BlockFieldMatrix.toBlocksLayout(T[][] rawData)
Convert a data array from raw layout to blocks layout.
Constructors in org.apache.commons.math4.linear that throw DimensionMismatchException
Constructor and 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.math4.ml.distance

Methods in org.apache.commons.math4.ml.distance that throw DimensionMismatchException
Modifier and Type Method and Description
double ManhattanDistance.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 EarthMoversDistance.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 CanberraDistance.compute(double[] a, double[] b)
Compute the distance between two n-dimensional vectors.
• ### Uses of DimensionMismatchException in org.apache.commons.math4.ode

Methods in org.apache.commons.math4.ode that throw DimensionMismatchException
Modifier and Type Method and 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.
void ExpandableStatefulODE.computeDerivatives(double t, double[] y, double[] yDot)
Get the current time derivative of the complete state vector.
void FirstOrderDifferentialEquations.computeDerivatives(double t, double[] y, double[] yDot)
Get the current time derivative of the state vector.
void AbstractIntegrator.computeDerivatives(double t, double[] y, double[] yDot)
Compute the derivatives and check the number of evaluations.
void SecondaryEquations.computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary, double[] secondaryDot)
Compute the derivatives related to the secondary state parameters.
T[] FieldExpandableODE.computeDerivatives(T t, T[] y)
Get the current time derivative of the complete state vector.
T[] AbstractFieldIntegrator.computeDerivatives(T t, T[] y)
Compute the derivatives and check the number of evaluations.
T[] FieldSecondaryEquations.computeDerivatives(T t, T[] primary, T[] primaryDot, T[] secondary)
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 AbstractIntegrator.sanityChecks(ExpandableStatefulODE equations, double t)
Check the integration span.
protected void AbstractFieldIntegrator.sanityChecks(FieldODEState<T> eqn, T 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 MultistepIntegrator.start(double t0, double[] y0, double t)
Start the integration.
protected void MultistepFieldIntegrator.start(FieldExpandableODE<T> equations, FieldODEState<T> initialState, T t)
Start the integration.
Constructors in org.apache.commons.math4.ode that throw DimensionMismatchException
Constructor and 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.math4.ode.nonstiff

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

Modifier and Type Method and Description
PointValuePair CMAESOptimizer.optimize(OptimizationData... optData)
Stores data and performs the optimization.
• ### Uses of DimensionMismatchException in org.apache.commons.math4.random

Constructors in org.apache.commons.math4.random that throw DimensionMismatchException
Constructor and 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.math4.stat

Methods in org.apache.commons.math4.stat that throw DimensionMismatchException
Modifier and Type Method and 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.math4.stat.correlation

Methods in org.apache.commons.math4.stat.correlation that throw DimensionMismatchException
Modifier and Type Method and 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.math4.stat.descriptive

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

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

Methods in org.apache.commons.math4.stat.inference that throw DimensionMismatchException
Modifier and Type Method and 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.
static double InferenceTestUtils.chiSquare(double[] expected, long[] observed)
double ChiSquareTest.chiSquare(long[][] counts)
Computes the Chi-Square statistic associated with a chi-square test of independence based on the input counts array, viewed as a two-way table.
static double InferenceTestUtils.chiSquare(long[][] counts)
double ChiSquareTest.chiSquareDataSetsComparison(long[] observed1, long[] observed2)
Computes a Chi-Square two sample test statistic comparing bin frequency counts in observed1 and observed2.
static double InferenceTestUtils.chiSquareDataSetsComparison(long[] observed1, long[] observed2)
double ChiSquareTest.chiSquareTest(double[] expected, long[] observed)
Returns the observed significance level, or p-value, associated with a Chi-square goodness of fit test comparing the observed frequency counts to those in the expected array.
static double InferenceTestUtils.chiSquareTest(double[] expected, long[] observed)
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.
static boolean InferenceTestUtils.chiSquareTest(double[] expected, long[] observed, double 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.
static double InferenceTestUtils.chiSquareTest(long[][] counts)
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 boolean InferenceTestUtils.chiSquareTest(long[][] counts, double alpha)
double ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
Returns the observed significance level, or p-value, associated with a Chi-Square two sample test comparing bin frequency counts in observed1 and observed2.
static double InferenceTestUtils.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
boolean ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
Performs a Chi-Square two sample test comparing two binned data sets.
static boolean InferenceTestUtils.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
double GTest.g(double[] expected, long[] observed)
Computes the G statistic for Goodness of Fit comparing observed and expected frequency counts.
static double InferenceTestUtils.g(double[] expected, long[] observed)
double GTest.gDataSetsComparison(long[] observed1, long[] observed2)
Computes a G (Log-Likelihood Ratio) two sample test statistic for independence comparing frequency counts in observed1 and observed2.
static double InferenceTestUtils.gDataSetsComparison(long[] observed1, long[] observed2)
double GTest.gTest(double[] expected, long[] observed)
Returns the observed significance level, or p-value, associated with a G-Test for goodness of fit comparing the observed frequency counts to those in the expected array.
static double InferenceTestUtils.gTest(double[] expected, long[] observed)
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 boolean InferenceTestUtils.gTest(double[] expected, long[] observed, double alpha)
double GTest.gTestDataSetsComparison(long[] observed1, long[] observed2)
Returns the observed significance level, or p-value, associated with a G-Value (Log-Likelihood Ratio) for two sample test comparing bin frequency counts in observed1 and observed2.
static double InferenceTestUtils.gTestDataSetsComparison(long[] observed1, long[] observed2)
boolean GTest.gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
Performs a G-Test (Log-Likelihood Ratio Test) comparing two binned data sets.
static boolean InferenceTestUtils.gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
double GTest.gTestIntrinsic(double[] expected, long[] observed)
Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described in p64-69 of McDonald, J.H.
static double InferenceTestUtils.gTestIntrinsic(double[] expected, long[] observed)
static double InferenceTestUtils.oneWayAnovaFValue(Collection<double[]> categoryData)
static double InferenceTestUtils.oneWayAnovaPValue(Collection<double[]> categoryData)
static boolean InferenceTestUtils.oneWayAnovaTest(Collection<double[]> categoryData, double alpha)
double TTest.pairedT(double[] sample1, double[] sample2)
Computes a paired, 2-sample t-statistic based on the data in the input arrays.
static double InferenceTestUtils.pairedT(double[] sample1, double[] sample2)
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.
static double InferenceTestUtils.pairedTTest(double[] sample1, double[] sample2)
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 boolean InferenceTestUtils.pairedTTest(double[] sample1, double[] sample2, double alpha)
static double InferenceTestUtils.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.math4.transform

Methods in org.apache.commons.math4.transform that throw DimensionMismatchException
Modifier and Type Method and Description
static org.apache.commons.numbers.complex.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.math4.util

Methods in org.apache.commons.math4.util that throw DimensionMismatchException
Modifier and Type Method and 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.
Decimal64 Decimal64.linearCombination(Decimal64[] a, Decimal64[] b)
Compute a linear combination.
Decimal64 Decimal64.linearCombination(double[] a, Decimal64[] b)
Compute a linear combination.
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.