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.
 



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