Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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

Packages that use DimensionMismatchException
org.apache.commons.math3.analysis.differentiation | This package holds the main interfaces and basic building block classes dealing with differentiation.
org.apache.commons.math3.analysis.function | The `function` package contains function objects that wrap the methods contained in `Math`, as well as common mathematical functions such as the gaussian and sinc functions.
org.apache.commons.math3.analysis.interpolation | Univariate real functions interpolation algorithms.
org.apache.commons.math3.complex | Complex number type and implementations of complex transcendental functions.
org.apache.commons.math3.distribution | Implementations of common discrete and continuous distributions.
org.apache.commons.math3.filter | Implementations of common discrete-time linear filters.
org.apache.commons.math3.genetics | This package provides Genetic Algorithms components and implementations.
org.apache.commons.math3.geometry.euclidean.threed | This package provides basic 3D geometry components.
org.apache.commons.math3.geometry.euclidean.twod | This package provides basic 2D geometry components.
org.apache.commons.math3.linear | Linear algebra support.
org.apache.commons.math3.ode | This package provides classes to solve Ordinary Differential Equations problems.
org.apache.commons.math3.ode.nonstiff | This package provides classes to solve non-stiff Ordinary Differential Equations problems.
org.apache.commons.math3.optim.nonlinear.scalar.noderiv | This package provides optimization algorithms that do not require derivatives.
org.apache.commons.math3.optim.nonlinear.vector | Algorithms for optimizing a vector function.
org.apache.commons.math3.optimization.direct | This package provides optimization algorithms that don't require derivatives.
org.apache.commons.math3.stat | Data storage, manipulation and summary routines.
org.apache.commons.math3.stat.correlation | Correlations/Covariance computations.
org.apache.commons.math3.stat.descriptive | Generic univariate summary statistic objects.
org.apache.commons.math3.stat.descriptive.moment | Summary statistics based on moments.
org.apache.commons.math3.stat.inference | Classes providing hypothesis testing and confidence interval construction.
org.apache.commons.math3.transform | Implementations of transform methods, including Fast Fourier transforms.
org.apache.commons.math3.util | Convenience routines and common data structures used throughout the commons-math library.

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

Methods in org.apache.commons.math3.analysis.differentiation that throw DimensionMismatchException
`DerivativeStructure` | `DerivativeStructure.add(DerivativeStructure a)` '+' operator.
`static DerivativeStructure` | `DerivativeStructure.atan2(DerivativeStructure y, DerivativeStructure x)` Two arguments arc tangent operation.
`void` | `DSCompiler.checkCompatibility(DSCompiler compiler)` Check rules set compatibility.
`DerivativeStructure` | `DerivativeStructure.divide(DerivativeStructure a)` '÷s;' operator.
`double` | `DerivativeStructure.getPartialDerivative(int... orders)` Get a partial derivative.
`int` | `DSCompiler.getPartialDerivativeIndex(int... orders)` Get the index of a partial derivative in the array.
`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.multiply(DerivativeStructure a)` '×' operator.
`DerivativeStructure` | `DerivativeStructure.pow(DerivativeStructure e)` Power operation.
`DerivativeStructure` | `DerivativeStructure.remainder(DerivativeStructure a)` '%' operator.
`DerivativeStructure` | `DerivativeStructure.subtract(DerivativeStructure a)` '-' operator.

Constructors in org.apache.commons.math3.analysis.differentiation that throw DimensionMismatchException
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2)` Linear combination constructor.
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3)` Linear combination constructor.
`DerivativeStructure(double a1, DerivativeStructure ds1, double a2, DerivativeStructure ds2, double a3, DerivativeStructure ds3, double a4, DerivativeStructure ds4)` Linear combination constructor.
`DerivativeStructure(int parameters, int order, double... derivatives)` Build an instance from all its derivatives.

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

Methods in org.apache.commons.math3.analysis.function that throw DimensionMismatchException
`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`.
`double[]` | `Sigmoid.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[]` | `Gaussian.Parametric.gradient(double x, double... param)` Computes the value of the gradient 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`.
`double` | `Sigmoid.Parametric.value(double x, double... param)` Computes the value of the sigmoid at `x`.
`double` | `Logistic.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`.

Constructors in org.apache.commons.math3.analysis.function that throw DimensionMismatchException
`StepFunction(double[] x, double[] y)` Builds a step function from a list of arguments and the corresponding values.

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

Methods in org.apache.commons.math3.analysis.interpolation that throw DimensionMismatchException
`protected static double[]` | `DividedDifferenceInterpolator.computeDividedDifference(double[] x, double[] y)` Return a copy of the divided difference array.
`MultivariateFunction` | `MicrosphereInterpolator.interpolate(double[][] xval, double[] yval)` Computes an interpolating function for the data set.
`PolynomialFunctionNewtonForm` | `DividedDifferenceInterpolator.interpolate(double[] x, double[] y)` Compute an interpolating function for the dataset.
`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.
`PolynomialSplineFunction` | `SplineInterpolator.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.
`PolynomialFunctionLagrangeForm` | `NevilleInterpolator.interpolate(double[] x, double[] y)` Computes an interpolating function for the data set.
`BicubicSplineInterpolatingFunction` | `SmoothingPolynomialBicubicSplineInterpolator.interpolate(double[] xval, double[] yval, double[][] fval)` Compute an interpolating function for the dataset.
`BicubicSplineInterpolatingFunction` | `BicubicSplineInterpolator.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.
`TricubicSplineInterpolatingFunction` | `TricubicSplineInterpolator.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.math3.analysis.interpolation that throw DimensionMismatchException
`BicubicSplineInterpolatingFunction(double[] x, double[] y, double[][] f, double[][] dFdX, double[][] dFdY, double[][] d2FdXdY)`
`MicrosphereInterpolatingFunction(double[][] xval, double[] yval, int brightnessExponent, int microsphereElements, UnitSphereRandomVectorGenerator rand)`
`TricubicSplineInterpolatingFunction(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.math3.complex

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

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

Methods in org.apache.commons.math3.distribution that throw DimensionMismatchException
`double` | `MultivariateNormalDistribution.density(double[] vals)` Returns the probability density function (PDF) of this distribution evaluated at the specified point `x`.

Constructors in org.apache.commons.math3.distribution that throw DimensionMismatchException
`MultivariateNormalDistribution(double[] means, double[][] covariances)` Creates a multivariate normal distribution with the given mean vector and covariance matrix.
`MultivariateNormalDistribution(RandomGenerator rng, double[] means, double[][] covariances)` Creates a multivariate normal distribution with the given mean vector and covariance matrix.

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

Methods in org.apache.commons.math3.filter that throw DimensionMismatchException
`void` | `KalmanFilter.correct(double[] z)` Correct the current state estimate with an actual measurement.
`void` | `KalmanFilter.correct(RealVector z)` Correct the current state estimate with an actual measurement.
`void` | `KalmanFilter.predict(double[] u)` Predict the internal state estimation one time step ahead.
`void` | `KalmanFilter.predict(RealVector u)` Predict the internal state estimation one time step ahead.

Constructors in org.apache.commons.math3.filter that throw DimensionMismatchException
`DefaultMeasurementModel(double[][] measMatrix, double[][] measNoise)` Create a new `MeasurementModel`, taking double arrays as input parameters for the respective measurement matrix and noise.
`DefaultProcessModel(double[][] stateTransition, double[][] control, double[][] processNoise)` Create a new `ProcessModel`, taking double arrays as input parameters.
`DefaultProcessModel(double[][] stateTransition, double[][] control, double[][] processNoise, double[] initialStateEstimate, double[][] initialErrorCovariance)` Create a new `ProcessModel`, taking double arrays as input parameters.
`KalmanFilter(ProcessModel process, MeasurementModel measurement)` Creates a new Kalman filter with the given process and measurement models.

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

Methods in org.apache.commons.math3.genetics that throw DimensionMismatchException
`ChromosomePair` | `CycleCrossover.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` | `NPointCrossover.crossover(Chromosome first, Chromosome second)` Performs a N-point crossover.
`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.
`static
`<S> List<Double>`
` | `RandomKey.inducedPermutation(List<S> originalData, List<S> permutedData)` Generates a representation of a permutation corresponding to a permutation which yields `permutedData` when applied to `originalData`.
`protected ChromosomePair` | `CycleCrossover.mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)` Helper for `CycleCrossover.crossover(Chromosome, Chromosome)`.
`protected ChromosomePair` | `OrderedCrossover.mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)` Helper for `OrderedCrossover.crossover(Chromosome, Chromosome)`.

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

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

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

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

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

Subclasses of DimensionMismatchException in org.apache.commons.math3.linear
`class` | `NonSquareMatrixException` Exception to be thrown when a square matrix is expected.
`class` | `NonSquareOperatorException` Exception to be thrown when a square linear operator is expected.

Methods in org.apache.commons.math3.linear that throw DimensionMismatchException
`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>` | `SparseFieldVector.add(FieldVector<T> v)` Deprecated. Compute the sum of `this` and `v`.
`FieldVector<T>` | `FieldVector.add(FieldVector<T> v)` Compute the sum of `this` and `v`.
`OpenMapRealVector` | `OpenMapRealVector.add(OpenMapRealVector v)` Deprecated. Optimized method to add two OpenMapRealVectors.
`ArrayRealVector` | `ArrayRealVector.add(RealVector v)` Compute the sum of this vector and `v`.
`RealVector` | `RealVector.add(RealVector v)` Compute the sum of this vector and `v`.
`RealVector` | `OpenMapRealVector.add(RealVector v)` Deprecated. Compute the sum of this vector and `v`.
`FieldVector<T>` | `SparseFieldVector.add(SparseFieldVector<T> v)` Deprecated. Optimized method to add sparse vectors.
`static void` | `MatrixUtils.checkMultiplicationCompatible(AnyMatrix left, AnyMatrix right)` Check if matrices are multiplication compatible
`protected void` | `AbstractFieldMatrix.checkMultiplicationCompatible(FieldMatrix<T> m)` Check if a matrix is multiplication compatible with the instance.
`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` | `SparseFieldVector.checkVectorDimensions(int n)` Deprecated. 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(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(RealVector v)` Check if instance and specified vectors have the same dimension.
`ArrayRealVector` | `ArrayRealVector.combine(double a, double b, RealVector y)` Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
`RealVector` | `RealVector.combine(double a, double b, RealVector y)` Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
`ArrayRealVector` | `ArrayRealVector.combineToSelf(double a, double b, RealVector y)` Updates `this` with the linear combination of `this` and `y`.
`RealVector` | `RealVector.combineToSelf(double a, double b, RealVector y)` Updates `this` with the linear combination of `this` and `y`.
`double` | `RealVector.cosine(RealVector v)` Computes the cosine of the angle between this vector and the argument.
`static
`<T extends FieldElement<T>> FieldMatrix<T>`
` | `MatrixUtils.createFieldMatrix(T[][] data)` Returns a `FieldMatrix` whose entries are the the values in the the input array.
`RealMatrix` | `DiagonalMatrix.createMatrix(int rowDimension, int columnDimension)` Create a new RealMatrix of the same type as the instance with the supplied row and column dimensions.
`static RealMatrix` | `MatrixUtils.createRealMatrix(double[][] data)` Returns a `RealMatrix` whose entries are the the values in the the input array.
`T` | `ArrayFieldVector.dotProduct(ArrayFieldVector<T> v)` Compute the dot product.
`T` | `ArrayFieldVector.dotProduct(FieldVector<T> v)` Compute the dot product.
`T` | `SparseFieldVector.dotProduct(FieldVector<T> v)` Deprecated. Compute the dot product.
`T` | `FieldVector.dotProduct(FieldVector<T> v)` Compute the dot product.
`double` | `OpenMapRealVector.dotProduct(OpenMapRealVector v)` Deprecated. as of 3.1 (to be removed in 4.0). The computation is performed by the parent class. The method must be kept to maintain backwards compatibility.
`double` | `ArrayRealVector.dotProduct(RealVector v)` Compute the dot product of this vector with `v`.
`double` | `RealVector.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>` | `SparseFieldVector.ebeDivide(FieldVector<T> v)` Deprecated. Element-by-element division.
`FieldVector<T>` | `FieldVector.ebeDivide(FieldVector<T> v)` Element-by-element division.
`ArrayRealVector` | `ArrayRealVector.ebeDivide(RealVector v)` Element-by-element division.
`abstract RealVector` | `RealVector.ebeDivide(RealVector v)` Deprecated. As of version 3.1, this method is deprecated, and will be removed in version 4.0. This decision follows the discussion reported in MATH-803. Uses of this method involving sparse implementations of `RealVector` might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement `RealVectorPreservingVisitor` (possibly ignoring corner cases for the sake of efficiency).
`OpenMapRealVector` | `OpenMapRealVector.ebeDivide(RealVector v)` Deprecated. 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>` | `SparseFieldVector.ebeMultiply(FieldVector<T> v)` Deprecated. Element-by-element multiplication.
`FieldVector<T>` | `FieldVector.ebeMultiply(FieldVector<T> v)` Element-by-element multiplication.
`ArrayRealVector` | `ArrayRealVector.ebeMultiply(RealVector v)` Element-by-element multiplication.
`abstract RealVector` | `RealVector.ebeMultiply(RealVector v)` Deprecated. As of version 3.1, this method is deprecated, and will be removed in version 4.0. This decision follows the discussion reported in MATH-803. Uses of this method involving sparse implementations of `RealVector` might lead to wrong results. Since there is no satisfactory correction to this bug, this method is deprecated. Users who want to preserve this feature are advised to implement `RealVectorPreservingVisitor` (possibly ignoring corner cases for the sake of efficiency).
`OpenMapRealVector` | `OpenMapRealVector.ebeMultiply(RealVector v)` Deprecated. Element-by-element multiplication.
`double` | `OpenMapRealVector.getDistance(OpenMapRealVector v)` Deprecated. Optimized method to compute distance.
`double` | `ArrayRealVector.getDistance(RealVector v)` Distance between two vectors.
`double` | `RealVector.getDistance(RealVector v)` Distance between two vectors.
`double` | `OpenMapRealVector.getDistance(RealVector v)` Deprecated. Distance between two vectors.
`double` | `OpenMapRealVector.getL1Distance(OpenMapRealVector v)` Deprecated. Distance between two vectors.
`double` | `ArrayRealVector.getL1Distance(RealVector v)` Distance between two vectors.
`double` | `RealVector.getL1Distance(RealVector v)` Distance between two vectors.
`double` | `OpenMapRealVector.getL1Distance(RealVector v)` Deprecated. Distance between two vectors.
`double` | `ArrayRealVector.getLInfDistance(RealVector v)` Distance between two vectors.
`double` | `RealVector.getLInfDistance(RealVector v)` Distance between two vectors.
`double` | `OpenMapRealVector.getLInfDistance(RealVector v)` Deprecated. 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>` | `FieldMatrix.multiply(FieldMatrix<T> m)` Postmultiply this matrix 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`.
`OpenMapRealMatrix` | `OpenMapRealMatrix.multiply(OpenMapRealMatrix m)` Deprecated. Postmultiply this matrix by `m`.
`RealMatrix` | `AbstractRealMatrix.multiply(RealMatrix m)` Returns the result of postmultiplying `this` by `m`.
`RealMatrix` | `DiagonalMatrix.multiply(RealMatrix m)` Returns the result of postmultiplying `this` by `m`.
`RealMatrix` | `RealMatrix.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` | `OpenMapRealMatrix.multiply(RealMatrix m)` Deprecated. Returns the result of postmultiplying `this` by `m`.
`double[]` | `Array2DRowRealMatrix.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`.
`double[]` | `DiagonalMatrix.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[]` | `BlockRealMatrix.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`.
`FieldVector<T>` | `AbstractFieldMatrix.operate(FieldVector<T> 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`.
`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`.
`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`.
`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`.
`RealVector` | `RealLinearOperator.operateTranspose(RealVector x)` Returns the result of multiplying the transpose of `this` operator by the vector `x` (optional operation).
`double[]` | `Array2DRowRealMatrix.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`.
`double[]` | `DiagonalMatrix.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[]` | `BlockRealMatrix.preMultiply(double[] 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`.
`FieldMatrix<T>` | `AbstractFieldMatrix.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`.
`FieldVector<T>` | `AbstractFieldMatrix.preMultiply(FieldVector<T> 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`.
`RealMatrix` | `RealMatrix.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`.
`RealVector` | `RealMatrix.preMultiply(RealVector 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`.
`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`.
`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>` | `SparseFieldVector.projection(FieldVector<T> v)` Deprecated. Find the orthogonal projection of this vector onto another vector.
`FieldVector<T>` | `FieldVector.projection(FieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
`RealVector` | `RealVector.projection(RealVector v)` Find the orthogonal projection of this vector onto another vector.
`void` | `Array2DRowRealMatrix.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` | `RealMatrix.setSubMatrix(double[][] 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` | `Array2DRowFieldMatrix.setSubMatrix(T[][] 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.
`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` | `PreconditionedIterativeLinearSolver.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)` 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` | `PreconditionedIterativeLinearSolver.solve(RealLinearOperator a, RealVector b, RealVector x0)` 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` | `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.
`RealVector` | `PreconditionedIterativeLinearSolver.solveInPlace(RealLinearOperator a, 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.
`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>` | `SparseFieldVector.subtract(FieldVector<T> v)` Deprecated. Compute `this` minus `v`.
`FieldVector<T>` | `FieldVector.subtract(FieldVector<T> v)` Compute `this` minus `v`.
`OpenMapRealVector` | `OpenMapRealVector.subtract(OpenMapRealVector v)` Deprecated. Optimized method to subtract OpenMapRealVectors.
`ArrayRealVector` | `ArrayRealVector.subtract(RealVector v)` Subtract `v` from this vector.
`RealVector` | `RealVector.subtract(RealVector v)` Subtract `v` from this vector.
`RealVector` | `OpenMapRealVector.subtract(RealVector v)` Deprecated. Subtract `v` from this vector.
`SparseFieldVector<T>` | `SparseFieldVector.subtract(SparseFieldVector<T> v)` Deprecated. 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.math3.linear that throw DimensionMismatchException
`Array2DRowFieldMatrix(Field<T> field, T[][] d)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(Field<T> field, T[][] d, boolean copyArray)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(T[][] d)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowFieldMatrix(T[][] d, boolean copyArray)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
`Array2DRowRealMatrix(double[][] d)` Create a new `RealMatrix` using the input array as the underlying data array.
`Array2DRowRealMatrix(double[][] d, boolean copyArray)` Create a new RealMatrix using the input array as the underlying data array.
`BlockFieldMatrix(int rows, int columns, T[][] blockData, boolean copyArray)` Create a new dense matrix copying entries from block layout data.
`BlockFieldMatrix(T[][] rawData)` Create a new dense matrix copying entries from raw layout data.
`BlockRealMatrix(double[][] rawData)` Create a new dense matrix copying entries from raw layout data.
`BlockRealMatrix(int rows, int columns, double[][] blockData, boolean copyArray)` Create a new dense matrix copying entries from block layout data.

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

Methods in org.apache.commons.math3.ode that throw DimensionMismatchException
`protected double` | `AbstractIntegrator.acceptStep(AbstractStepInterpolator interpolator, double[] y, double[] yDot, double tEnd)` Accept a step, triggering events and step handlers.
`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.
`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.
`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.
`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.
`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.
`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.

Constructors in org.apache.commons.math3.ode that throw DimensionMismatchException
`JacobianMatrices(FirstOrderDifferentialEquations fode, double[] hY, String... parameters)` Simple constructor for a secondary equations set computing Jacobian matrices.

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

Methods in org.apache.commons.math3.ode.nonstiff that throw DimensionMismatchException
`double` | `AdaptiveStepsizeIntegrator.initializeStep(boolean forward, int order, double[] scale, double t0, double[] y0, double[] yDot0, double[] y1, double[] yDot1)` Initialize the integration step.
`abstract void` | `AdamsIntegrator.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` | `GraggBulirschStoerIntegrator.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.
`void` | `AdamsMoultonIntegrator.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.
`protected void` | `AdaptiveStepsizeIntegrator.sanityChecks(ExpandableStatefulODE equations, double t)` Check the integration span.

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

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

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

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

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

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

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

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

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

Methods in org.apache.commons.math3.stat.correlation that throw DimensionMismatchException
`void` | `StorelessCovariance.increment(double[] data)` Increment the covariance matrix with one row of data.

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

Methods in org.apache.commons.math3.stat.descriptive that throw DimensionMismatchException
`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.math3.stat.descriptive.moment

Methods in org.apache.commons.math3.stat.descriptive.moment that throw DimensionMismatchException
`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.math3.stat.inference

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

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

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

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

Methods in org.apache.commons.math3.util that throw DimensionMismatchException
`static void` | `MathArrays.checkRectangular(long[][] in)` Throws DimensionMismatchException if the input array is not rectangular.
`int` | `MultidimensionalCounter.getCount(int... c)` Convert to unidimensional counter.
`static double` | `MathArrays.linearCombination(double[] a, double[] b)` Compute a linear combination accurately.
`static void` | `MathArrays.sortInPlace(double[] x, double[]... yList)` Sort an array in ascending order in place and perform the same reordering of entries on other arrays.
`static void` | `MathArrays.sortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList)` Sort an array in place and perform the same reordering of entries on other arrays.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2003-2013 The Apache Software Foundation. All Rights Reserved.