Uses of Class
org.apache.commons.math4.legacy.exception.DimensionMismatchException

Packages that use DimensionMismatchException

Package	Description
org.apache.commons.math4.legacy.analysis.differentiation	This package holds the main interfaces and basic building block classes dealing with differentiation.
org.apache.commons.math4.legacy.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.legacy.analysis.interpolation	Univariate real functions interpolation algorithms.
org.apache.commons.math4.legacy.analysis.polynomials	Univariate real polynomials implementations, seen as differentiable univariate real functions.
org.apache.commons.math4.legacy.core	Core math utilities.
org.apache.commons.math4.legacy.core.dfp	Decimal floating point library for Java
org.apache.commons.math4.legacy.distribution	Implementations of probability distributions.
org.apache.commons.math4.legacy.distribution.fitting	Fitting of parameters against distributions.
org.apache.commons.math4.legacy.filter	Implementations of common discrete-time linear filters.
org.apache.commons.math4.legacy.genetics	This package provides Genetic Algorithms components and implementations.
org.apache.commons.math4.legacy.linear	Linear algebra support.
org.apache.commons.math4.legacy.ode	This package provides classes to solve Ordinary Differential Equations problems.
org.apache.commons.math4.legacy.ode.nonstiff	This package provides classes to solve non-stiff Ordinary Differential Equations problems.
org.apache.commons.math4.legacy.stat	Data storage, manipulation and summary routines.
org.apache.commons.math4.legacy.stat.correlation	Correlations/Covariance computations.
org.apache.commons.math4.legacy.stat.descriptive	Generic univariate summary statistic objects.
org.apache.commons.math4.legacy.stat.descriptive.moment	Summary statistics based on moments.
org.apache.commons.math4.legacy.stat.inference	Classes providing hypothesis testing.

Uses of DimensionMismatchException in org.apache.commons.math4.legacy.analysis.differentiation

Methods in org.apache.commons.math4.legacy.analysis.differentiation that throw DimensionMismatchException

Modifier and Type	Method	Description
void	DSCompiler.checkCompatibility(DSCompiler compiler)	Check rules set compatibility.
int	DSCompiler.getPartialDerivativeIndex(int... orders)	Get the index of a partial derivative in the array.

Uses of DimensionMismatchException in org.apache.commons.math4.legacy.analysis.function

Methods in org.apache.commons.math4.legacy.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.math4.legacy.analysis.function that throw DimensionMismatchException

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.math4.legacy.analysis.interpolation

Methods in org.apache.commons.math4.legacy.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.
BivariateFunction	BivariateGridInterpolator.interpolate(double[] xval, double[] yval, double[][] fval)	Compute an interpolating function for the dataset.
PolynomialSplineFunction	ClampedSplineInterpolator.interpolate(double[] x, double[] y, double fpo, double fpn)	Computes an interpolating function for the data set.
PolynomialFunctionNewtonForm	DividedDifferenceInterpolator.interpolate(double[] x, double[] y)	Compute an interpolating function for the dataset.
PolynomialSplineFunction	LinearInterpolator.interpolate(double[] x, double[] y)	Computes a linear interpolating function for the data set.
PolynomialSplineFunction	LoessInterpolator.interpolate(double[] xval, double[] yval)	Compute an interpolating function by performing a loess fit on the data at the original abscissae and then building a cubic spline with a SplineInterpolator on the resulting fit.
MultivariateFunction	MicrosphereProjectionInterpolator.interpolate(double[][] xval, double[] yval)	Computes an interpolating function for the data set.
MultivariateFunction	MultivariateInterpolator.interpolate(double[][] xval, double[] yval)	Computes an interpolating function for the data set.
PolynomialFunctionLagrangeForm	NevilleInterpolator.interpolate(double[] x, double[] y)	Computes an interpolating function for the data set.
PiecewiseBicubicSplineInterpolatingFunction	PiecewiseBicubicSplineInterpolator.interpolate(double[] xval, double[] yval, double[][] fval)	Compute an interpolating function for the dataset.
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.legacy.analysis.interpolation that throw DimensionMismatchException

Constructor	Description
BicubicInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)
BicubicInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY, boolean initializeDerivatives)
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.legacy.analysis.polynomials

Methods in org.apache.commons.math4.legacy.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.math4.legacy.analysis.polynomials that throw DimensionMismatchException

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.math4.legacy.core

Methods in org.apache.commons.math4.legacy.core 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.math4.legacy.core.dfp

Methods in org.apache.commons.math4.legacy.core.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.math4.legacy.distribution

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

Constructor	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.legacy.distribution.fitting

Methods in org.apache.commons.math4.legacy.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.math4.legacy.distribution.fitting that throw DimensionMismatchException

Constructor	Description
MultivariateNormalMixtureExpectationMaximization(double[][] data)	Creates an object to fit a multivariate normal mixture model to data.

Uses of DimensionMismatchException in org.apache.commons.math4.legacy.filter

Methods in org.apache.commons.math4.legacy.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.math4.legacy.filter that throw DimensionMismatchException

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.math4.legacy.genetics

Methods in org.apache.commons.math4.legacy.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.math4.legacy.linear

Subclasses of DimensionMismatchException in org.apache.commons.math4.legacy.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.math4.legacy.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 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 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.
double	ArrayRealVector.dotProduct(RealVector v)	Compute the dot product of this vector with v.
T	FieldVector.dotProduct(FieldVector<T> v)	Compute the dot product.
double	RealVector.dotProduct(RealVector v)	Compute the dot product of this vector with v.
T	SparseFieldVector.dotProduct(FieldVector<T> v)	Compute the dot product.
ArrayFieldVector<T>	ArrayFieldVector.ebeDivide(ArrayFieldVector<T> v)	Element-by-element division.
FieldVector<T>	ArrayFieldVector.ebeDivide(FieldVector<T> v)	Element-by-element division.
ArrayRealVector	ArrayRealVector.ebeDivide(RealVector v)	Element-by-element division.
FieldVector<T>	FieldVector.ebeDivide(FieldVector<T> v)	Element-by-element division.
OpenMapRealVector	OpenMapRealVector.ebeDivide(RealVector v)	Element-by-element division.
abstract RealVector	RealVector.ebeDivide(RealVector v)	Element-by-element division.
FieldVector<T>	SparseFieldVector.ebeDivide(FieldVector<T> v)	Element-by-element division.
ArrayFieldVector<T>	ArrayFieldVector.ebeMultiply(ArrayFieldVector<T> v)	Element-by-element multiplication.
FieldVector<T>	ArrayFieldVector.ebeMultiply(FieldVector<T> v)	Element-by-element multiplication.
ArrayRealVector	ArrayRealVector.ebeMultiply(RealVector v)	Element-by-element multiplication.
FieldVector<T>	FieldVector.ebeMultiply(FieldVector<T> v)	Element-by-element multiplication.
OpenMapRealVector	OpenMapRealVector.ebeMultiply(RealVector v)	Element-by-element multiplication.
abstract RealVector	RealVector.ebeMultiply(RealVector v)	Element-by-element multiplication.
FieldVector<T>	SparseFieldVector.ebeMultiply(FieldVector<T> v)	Element-by-element multiplication.
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.
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.
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.
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	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.math4.legacy.linear that throw DimensionMismatchException

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.
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.legacy.ode

Methods in org.apache.commons.math4.legacy.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.math4.legacy.ode that throw DimensionMismatchException

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.math4.legacy.ode.nonstiff

Methods in org.apache.commons.math4.legacy.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.math4.legacy.stat

Methods in org.apache.commons.math4.legacy.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.math4.legacy.stat.correlation

Methods in org.apache.commons.math4.legacy.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.math4.legacy.stat.descriptive

Methods in org.apache.commons.math4.legacy.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.math4.legacy.stat.descriptive.moment

Methods in org.apache.commons.math4.legacy.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.math4.legacy.stat.inference

Methods in org.apache.commons.math4.legacy.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	InferenceTestUtils.chiSquare(double[] expected, long[] observed)
static double	InferenceTestUtils.chiSquare(long[][] counts)
double	ChiSquareTest.chiSquareDataSetsComparison(long[] observed1, long[] observed2)	Computes a Chi-Square two sample test statistic comparing bin frequency counts in observed1 and observed2.
static double	InferenceTestUtils.chiSquareDataSetsComparison(long[] observed1, long[] observed2)
double	ChiSquareTest.chiSquareTest(double[] expected, long[] observed)	Returns the observed significance level, or p-value, associated with a Chi-square goodness of fit test comparing the observed frequency counts to those in the expected array.
boolean	ChiSquareTest.chiSquareTest(double[] expected, long[] observed, double alpha)	Performs a Chi-square goodness of fit test evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level alpha.
double	ChiSquareTest.chiSquareTest(long[][] counts)	Returns the observed significance level, or p-value, associated with a chi-square test of independence based on the input counts array, viewed as a two-way table.
boolean	ChiSquareTest.chiSquareTest(long[][] counts, double alpha)	Performs a chi-square test of independence evaluating the null hypothesis that the classifications represented by the counts in the columns of the input 2-way table are independent of the rows, with significance level alpha.
static double	InferenceTestUtils.chiSquareTest(double[] expected, long[] observed)
static boolean	InferenceTestUtils.chiSquareTest(double[] expected, long[] observed, double alpha)
static double	InferenceTestUtils.chiSquareTest(long[][] counts)
static boolean	InferenceTestUtils.chiSquareTest(long[][] counts, double alpha)
double	ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)	Returns the observed significance level, or p-value, associated with a Chi-Square two sample test comparing bin frequency counts in observed1 and observed2.
boolean	ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)	Performs a Chi-Square two sample test comparing two binned data sets.
static double	InferenceTestUtils.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
static boolean	InferenceTestUtils.chiSquareTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
double	GTest.g(double[] expected, long[] observed)	Computes the G statistic for Goodness of Fit comparing observed and expected frequency counts.
static double	InferenceTestUtils.g(double[] expected, long[] observed)
double	GTest.gDataSetsComparison(long[] observed1, long[] observed2)	Computes a G (Log-Likelihood Ratio) two sample test statistic for independence comparing frequency counts in observed1 and observed2.
static double	InferenceTestUtils.gDataSetsComparison(long[] observed1, long[] observed2)
double	GTest.gTest(double[] expected, long[] observed)	Returns the observed significance level, or p-value, associated with a G-Test for goodness of fit comparing the observed frequency counts to those in the expected array.
boolean	GTest.gTest(double[] expected, long[] observed, double alpha)	Performs a G-Test (Log-Likelihood Ratio Test) for goodness of fit evaluating the null hypothesis that the observed counts conform to the frequency distribution described by the expected counts, with significance level alpha.
static double	InferenceTestUtils.gTest(double[] expected, long[] observed)
static boolean	InferenceTestUtils.gTest(double[] expected, long[] observed, double alpha)
double	GTest.gTestDataSetsComparison(long[] observed1, long[] observed2)	Returns the observed significance level, or p-value, associated with a G-Value (Log-Likelihood Ratio) for two sample test comparing bin frequency counts in observed1 and observed2.
boolean	GTest.gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)	Performs a G-Test (Log-Likelihood Ratio Test) comparing two binned data sets.
static double	InferenceTestUtils.gTestDataSetsComparison(long[] observed1, long[] observed2)
static boolean	InferenceTestUtils.gTestDataSetsComparison(long[] observed1, long[] observed2, double alpha)
double	GTest.gTestIntrinsic(double[] expected, long[] observed)	Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described in p64-69 of McDonald, J.H.
static double	InferenceTestUtils.gTestIntrinsic(double[] expected, long[] observed)
static double	InferenceTestUtils.oneWayAnovaFValue(Collection<double[]> categoryData)
static double	InferenceTestUtils.oneWayAnovaPValue(Collection<double[]> categoryData)
static boolean	InferenceTestUtils.oneWayAnovaTest(Collection<double[]> categoryData, double alpha)
static double	InferenceTestUtils.pairedT(double[] sample1, double[] sample2)
double	TTest.pairedT(double[] sample1, double[] sample2)	Computes a paired, 2-sample t-statistic based on the data in the input arrays.
static double	InferenceTestUtils.pairedTTest(double[] sample1, double[] sample2)
static boolean	InferenceTestUtils.pairedTTest(double[] sample1, double[] sample2, double alpha)
double	TTest.pairedTTest(double[] sample1, double[] sample2)	Returns the observed significance level, or p-value, associated with a paired, two-sample, two-tailed t-test based on the data in the input arrays.
boolean	TTest.pairedTTest(double[] sample1, double[] sample2, double alpha)	Performs a paired t-test evaluating the null hypothesis that the mean of the paired differences between sample1 and sample2 is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0, with significance level alpha.
static double	InferenceTestUtils.rootLogLikelihoodRatio(long k11, long k12, long k21, long k22)
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.