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

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

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

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

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

    Methods in org.apache.commons.math3.analysis.differentiation that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `DerivativeStructure` | DerivativeStructure.`add(DerivativeStructure a)` Compute this + a.
    `DerivativeStructure` | DerivativeStructure.`atan2(DerivativeStructure x)` Two arguments arc tangent operation.
    `static DerivativeStructure` | DerivativeStructure.`atan2(DerivativeStructure y, DerivativeStructure x)` Two arguments arc tangent operation.
    `void` | DSCompiler.`checkCompatibility(DSCompiler compiler)` Check rules set compatibility.
    `DerivativeStructure` | DerivativeStructure.`compose(double... f)` Compute composition of the instance by a univariate function.
    `DerivativeStructure` | DerivativeStructure.`divide(DerivativeStructure a)` Compute this ÷ a.
    `double` | DerivativeStructure.`getPartialDerivative(int... orders)` Get a partial derivative.
    `int` | DSCompiler.`getPartialDerivativeIndex(int... orders)` Get the index of a partial derivative in the array.
    `DerivativeStructure` | DerivativeStructure.`hypot(DerivativeStructure y)` Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this2 +y2) avoiding intermediate overflow or underflow.
    `static DerivativeStructure` | DerivativeStructure.`hypot(DerivativeStructure x, DerivativeStructure y)` Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2) avoiding intermediate overflow or underflow.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(DerivativeStructure[] a, DerivativeStructure[] b)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2, DerivativeStructure a3, DerivativeStructure b3)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(DerivativeStructure a1, DerivativeStructure b1, DerivativeStructure a2, DerivativeStructure b2, DerivativeStructure a3, DerivativeStructure b3, DerivativeStructure a4, DerivativeStructure b4)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(double[] a, DerivativeStructure[] b)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2, double a3, DerivativeStructure b3)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`linearCombination(double a1, DerivativeStructure b1, double a2, DerivativeStructure b2, double a3, DerivativeStructure b3, double a4, DerivativeStructure b4)` Compute a linear combination.
    `SparseGradient` | SparseGradient.`linearCombination(SparseGradient[] a, SparseGradient[] b)` Compute a linear combination.
    `DerivativeStructure` | DerivativeStructure.`multiply(DerivativeStructure a)` Compute this × a.
    `DerivativeStructure` | DerivativeStructure.`pow(DerivativeStructure e)` Power operation.
    `DerivativeStructure` | DerivativeStructure.`remainder(DerivativeStructure a)` IEEE remainder operator.
    `DerivativeStructure` | DerivativeStructure.`subtract(DerivativeStructure a)` Compute this - a.
    `DerivativeStructure` | UnivariateDifferentiableFunction.`value(DerivativeStructure t)` Simple mathematical function.

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

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

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

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

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

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

    Constructors in org.apache.commons.math3.analysis.integration.gauss that throw DimensionMismatchException
    Constructor and Description
    `GaussIntegrator(double[] points, double[] weights)` Creates an integrator from the given `points` and `weights`.
    `SymmetricGaussIntegrator(double[] points, double[] weights)` Creates an integrator from the given `points` and `weights`.

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

    Methods in org.apache.commons.math3.analysis.interpolation that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `void` | FieldHermiteInterpolator.`addSamplePoint(T x, T[]... value)` Add a sample point.
    `protected static double[]` | DividedDifferenceInterpolator.`computeDividedDifference(double[] x, double[] y)` Return a copy of the divided difference array.
    `MultivariateFunction` | MicrosphereInterpolator.`interpolate(double[][] xval, double[] yval)` Computes an interpolating function for the data set.
    `MultivariateFunction` | MultivariateInterpolator.`interpolate(double[][] xval, double[] yval)` Computes an interpolating function for the data set.
    `PolynomialFunctionLagrangeForm` | NevilleInterpolator.`interpolate(double[] x, double[] y)` Computes an interpolating function for the data set.
    `PolynomialSplineFunction` | LinearInterpolator.`interpolate(double[] x, double[] y)` Computes a linear interpolating function for the data set.
    `PolynomialSplineFunction` | SplineInterpolator.`interpolate(double[] x, double[] y)` Computes an interpolating function for the data set.
    `PolynomialSplineFunction` | LoessInterpolator.`interpolate(double[] xval, double[] yval)` Compute an interpolating function by performing a loess fit on the data at the original abscissae and then building a cubic spline with a `SplineInterpolator` on the resulting fit.
    `UnivariateFunction` | UnivariateInterpolator.`interpolate(double[] xval, double[] yval)` Compute an interpolating function for the dataset.
    `PolynomialFunctionNewtonForm` | DividedDifferenceInterpolator.`interpolate(double[] x, double[] y)` Compute an interpolating function for the dataset.
    `BivariateFunction` | BivariateGridInterpolator.`interpolate(double[] xval, double[] yval, double[][] fval)` Compute an interpolating function for the dataset.
    `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.
    `TrivariateFunction` | TrivariateGridInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)` Compute an interpolating function for the dataset.
    `TricubicSplineInterpolatingFunction` | TricubicSplineInterpolator.`interpolate(double[] xval, double[] yval, double[] zval, double[][][] fval)` 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.
    `double` | MicrosphereInterpolatingFunction.`value(double[] point)`

    Constructors in org.apache.commons.math3.analysis.interpolation that throw DimensionMismatchException
    Constructor and Description
    `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.analysis.polynomials

    Methods in org.apache.commons.math3.analysis.polynomials that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `static double` | PolynomialFunctionNewtonForm.`evaluate(double[] a, double[] c, double z)` Evaluate the Newton polynomial using nested multiplication.
    `static double` | PolynomialFunctionLagrangeForm.`evaluate(double[] x, double[] y, double z)` Evaluate the Lagrange polynomial using Neville's Algorithm.
    `protected static void` | PolynomialFunctionNewtonForm.`verifyInputArray(double[] a, double[] c)` Verifies that the input arrays are valid.
    `static boolean` | PolynomialFunctionLagrangeForm.`verifyInterpolationArray(double[] x, double[] y, boolean abort)` Check that the interpolation arrays are valid.

    Constructors in org.apache.commons.math3.analysis.polynomials that throw DimensionMismatchException
    Constructor and Description
    `PolynomialFunctionLagrangeForm(double[] x, double[] y)` Construct a Lagrange polynomial with the given abscissas and function values.
    `PolynomialFunctionNewtonForm(double[] a, double[] c)` Construct a Newton polynomial with the given a[] and c[].
    `PolynomialSplineFunction(double[] knots, PolynomialFunction[] polynomials)` Construct a polynomial spline function with the given segment delimiters and interpolating polynomials.

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

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

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

    Methods in org.apache.commons.math3.dfp that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `Dfp` | Dfp.`atan2(Dfp x)` Two arguments arc tangent operation.
    `Dfp` | Dfp.`linearCombination(Dfp[] a, Dfp[] b)` Compute a linear combination.
    `Dfp` | Dfp.`linearCombination(double[] a, Dfp[] b)` Compute a linear combination.

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

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

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

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

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

    Constructors in org.apache.commons.math3.distribution.fitting that throw DimensionMismatchException
    Constructor and Description
    `MultivariateNormalMixtureExpectationMaximization(double[][] data)` Creates an object to fit a multivariate normal mixture model to data.

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

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

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

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

    Methods in org.apache.commons.math3.genetics that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `ChromosomePair` | NPointCrossover.`crossover(Chromosome first, Chromosome second)` Performs a N-point crossover.
    `ChromosomePair` | OrderedCrossover.`crossover(Chromosome first, Chromosome second)` Perform a crossover operation on the given chromosomes.
    `ChromosomePair` | OnePointCrossover.`crossover(Chromosome first, Chromosome second)` Performs one point crossover.
    `ChromosomePair` | UniformCrossover.`crossover(Chromosome first, Chromosome second)` Perform a crossover operation on the given chromosomes.
    `ChromosomePair` | CycleCrossover.`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` | OrderedCrossover.`mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)` Helper for `OrderedCrossover.crossover(Chromosome, Chromosome)`.
    `protected ChromosomePair` | CycleCrossover.`mate(AbstractListChromosome<T> first, AbstractListChromosome<T> second)` Helper for `CycleCrossover.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
    Constructor and Description
    `FieldVector3D(T[] v)` Simple constructor.
    `Vector3D(double[] v)` Simple constructor.

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

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

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

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

    Methods in org.apache.commons.math3.linear that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `ArrayFieldVector<T>` | ArrayFieldVector.`add(ArrayFieldVector<T> v)` Compute the sum of `this` and `v`.
    `FieldVector<T>` | ArrayFieldVector.`add(FieldVector<T> v)` Compute the sum of `this` and `v`.
    `FieldVector<T>` | SparseFieldVector.`add(FieldVector<T> v)` Compute the sum of `this` and `v`.
    `FieldVector<T>` | FieldVector.`add(FieldVector<T> v)` Compute the sum of `this` and `v`.
    `OpenMapRealVector` | OpenMapRealVector.`add(OpenMapRealVector v)` Optimized method to add two OpenMapRealVectors.
    `RealVector` | RealVector.`add(RealVector v)` Compute the sum of this vector and `v`.
    `ArrayRealVector` | ArrayRealVector.`add(RealVector v)` Compute the sum of this vector and `v`.
    `RealVector` | OpenMapRealVector.`add(RealVector v)` Compute the sum of this vector and `v`.
    `FieldVector<T>` | SparseFieldVector.`add(SparseFieldVector<T> v)` 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)` 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(int n)` Check if instance dimension is equal to some expected value.
    `protected void` | RealVector.`checkVectorDimensions(RealVector v)` Check if instance and specified vectors have the same dimension.
    `protected void` | ArrayRealVector.`checkVectorDimensions(RealVector v)` Check if instance and specified vectors have the same dimension.
    `RealVector` | RealVector.`combine(double a, double b, RealVector y)` Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
    `ArrayRealVector` | ArrayRealVector.`combine(double a, double b, RealVector y)` Returns a new vector representing `a * this + b * y`, the linear combination of `this` and `y`.
    `RealVector` | RealVector.`combineToSelf(double a, double b, RealVector y)` Updates `this` with the linear combination of `this` and `y`.
    `ArrayRealVector` | ArrayRealVector.`combineToSelf(double a, double b, RealVector y)` Updates `this` with the linear combination of `this` and `y`.
    `double` | RealVector.`cosine(RealVector v)` Computes the cosine of the angle between this vector and the argument.
    `static <T extends FieldElement<T>> FieldMatrix<T>` | MatrixUtils.`createFieldMatrix(T[][] data)` Returns a `FieldMatrix` whose entries are the 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)` 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` | RealVector.`dotProduct(RealVector v)` Compute the dot product of this vector with `v`.
    `double` | ArrayRealVector.`dotProduct(RealVector v)` Compute the dot product of this vector with `v`.
    `ArrayFieldVector<T>` | ArrayFieldVector.`ebeDivide(ArrayFieldVector<T> v)` Element-by-element division.
    `FieldVector<T>` | ArrayFieldVector.`ebeDivide(FieldVector<T> v)` Element-by-element division.
    `FieldVector<T>` | SparseFieldVector.`ebeDivide(FieldVector<T> v)` Element-by-element division.
    `FieldVector<T>` | FieldVector.`ebeDivide(FieldVector<T> v)` Element-by-element division.
    `abstract RealVector` | RealVector.`ebeDivide(RealVector v)` Element-by-element division.
    `ArrayRealVector` | ArrayRealVector.`ebeDivide(RealVector v)` Element-by-element division.
    `OpenMapRealVector` | OpenMapRealVector.`ebeDivide(RealVector v)` Element-by-element division.
    `ArrayFieldVector<T>` | ArrayFieldVector.`ebeMultiply(ArrayFieldVector<T> v)` Element-by-element multiplication.
    `FieldVector<T>` | ArrayFieldVector.`ebeMultiply(FieldVector<T> v)` Element-by-element multiplication.
    `FieldVector<T>` | SparseFieldVector.`ebeMultiply(FieldVector<T> v)` Element-by-element multiplication.
    `FieldVector<T>` | FieldVector.`ebeMultiply(FieldVector<T> v)` Element-by-element multiplication.
    `abstract RealVector` | RealVector.`ebeMultiply(RealVector v)` Element-by-element multiplication.
    `ArrayRealVector` | ArrayRealVector.`ebeMultiply(RealVector v)` Element-by-element multiplication.
    `OpenMapRealVector` | OpenMapRealVector.`ebeMultiply(RealVector v)` Element-by-element multiplication.
    `double` | OpenMapRealVector.`getDistance(OpenMapRealVector v)` Optimized method to compute distance.
    `double` | RealVector.`getDistance(RealVector v)` Distance between two vectors.
    `double` | ArrayRealVector.`getDistance(RealVector v)` Distance between two vectors.
    `double` | OpenMapRealVector.`getDistance(RealVector v)` Distance between two vectors.
    `double` | OpenMapRealVector.`getL1Distance(OpenMapRealVector v)` Distance between two vectors.
    `double` | RealVector.`getL1Distance(RealVector v)` Distance between two vectors.
    `double` | ArrayRealVector.`getL1Distance(RealVector v)` Distance between two vectors.
    `double` | OpenMapRealVector.`getL1Distance(RealVector v)` Distance between two vectors.
    `double` | RealVector.`getLInfDistance(RealVector v)` Distance between two vectors.
    `double` | ArrayRealVector.`getLInfDistance(RealVector v)` Distance between two vectors.
    `double` | OpenMapRealVector.`getLInfDistance(RealVector v)` Distance between two vectors.
    `Array2DRowFieldMatrix<T>` | Array2DRowFieldMatrix.`multiply(Array2DRowFieldMatrix<T> m)` Postmultiplying this matrix by `m`.
    `Array2DRowRealMatrix` | Array2DRowRealMatrix.`multiply(Array2DRowRealMatrix m)` Returns the result of postmultiplying `this` by `m`.
    `BlockFieldMatrix<T>` | BlockFieldMatrix.`multiply(BlockFieldMatrix<T> m)` Returns the result of postmultiplying `this` by `m`.
    `BlockRealMatrix` | BlockRealMatrix.`multiply(BlockRealMatrix m)` Returns the result of postmultiplying this by `m`.
    `DiagonalMatrix` | DiagonalMatrix.`multiply(DiagonalMatrix m)` Returns the result of postmultiplying `this` by `m`.
    `FieldMatrix<T>` | BlockFieldMatrix.`multiply(FieldMatrix<T> m)` Postmultiply this matrix 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`.
    `OpenMapRealMatrix` | OpenMapRealMatrix.`multiply(OpenMapRealMatrix m)` Postmultiply this matrix by `m`.
    `RealMatrix` | DiagonalMatrix.`multiply(RealMatrix m)` Returns the result of postmultiplying `this` by `m`.
    `RealMatrix` | OpenMapRealMatrix.`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` | AbstractRealMatrix.`multiply(RealMatrix m)` Returns the result of postmultiplying `this` by `m`.
    `RealMatrix` | RealMatrix.`multiply(RealMatrix m)` Returns the result of postmultiplying `this` by `m`.
    `double[]` | DiagonalMatrix.`operate(double[] v)` Returns the result of multiplying this by the vector `v`.
    `double[]` | Array2DRowRealMatrix.`operate(double[] v)` Returns the result of multiplying this by the vector `v`.
    `double[]` | BlockRealMatrix.`operate(double[] v)` Returns the result of multiplying this by the vector `v`.
    `double[]` | AbstractRealMatrix.`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`.
    `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`.
    `abstract RealVector` | RealLinearOperator.`operate(RealVector x)` Returns the result of multiplying `this` by the vector `x`.
    `RealVector` | AbstractRealMatrix.`operate(RealVector v)` 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[]` | BlockFieldMatrix.`operate(T[] v)` Returns the result of multiplying this by the vector `v`.
    `T[]` | FieldMatrix.`operate(T[] v)` Returns the result of multiplying this by the vector `v`.
    `T[]` | AbstractFieldMatrix.`operate(T[] v)` Returns the result of multiplying this by the vector `v`.
    `T[]` | Array2DRowFieldMatrix.`operate(T[] v)` Returns the result of multiplying this by the vector `v`.
    `RealVector` | RealLinearOperator.`operateTranspose(RealVector x)` Returns the result of multiplying the transpose of `this` operator by the vector `x` (optional operation).
    `double[]` | DiagonalMatrix.`preMultiply(double[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `double[]` | Array2DRowRealMatrix.`preMultiply(double[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `double[]` | BlockRealMatrix.`preMultiply(double[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `double[]` | AbstractRealMatrix.`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`.
    `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` | DiagonalMatrix.`preMultiply(RealVector v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `RealVector` | AbstractRealMatrix.`preMultiply(RealVector v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `RealVector` | RealMatrix.`preMultiply(RealVector v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `T[]` | BlockFieldMatrix.`preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `T[]` | FieldMatrix.`preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `T[]` | AbstractFieldMatrix.`preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `T[]` | Array2DRowFieldMatrix.`preMultiply(T[] v)` Returns the (row) vector result of premultiplying this by the vector `v`.
    `ArrayFieldVector<T>` | ArrayFieldVector.`projection(ArrayFieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `FieldVector<T>` | ArrayFieldVector.`projection(FieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `FieldVector<T>` | SparseFieldVector.`projection(FieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `FieldVector<T>` | FieldVector.`projection(FieldVector<T> v)` Find the orthogonal projection of this vector onto another vector.
    `RealVector` | RealVector.`projection(RealVector v)` Find the orthogonal projection of this vector onto another vector.
    `void` | Array2DRowRealMatrix.`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` | 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` | BlockFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
    `void` | FieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
    `void` | AbstractFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
    `void` | Array2DRowFieldMatrix.`setSubMatrix(T[][] subMatrix, int row, int column)` Replace the submatrix starting at `(row, column)` using data in the input `subMatrix` array.
    `RealVector` | SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, boolean goodb, double shift)` Returns an estimate of the solution to the linear system (A - shift · I) · x = b.
    `RealVector` | SymmLQ.`solve(RealLinearOperator a, RealLinearOperator m, RealVector b, RealVector x)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | 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, 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` | PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealVector b)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | SymmLQ.`solve(RealLinearOperator a, RealVector b, boolean goodb, double shift)` Returns the solution to the system (A - shift · I) · x = b.
    `RealVector` | SymmLQ.`solve(RealLinearOperator a, RealVector b, RealVector x)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | IterativeLinearSolver.`solve(RealLinearOperator a, RealVector b, RealVector x0)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | PreconditionedIterativeLinearSolver.`solve(RealLinearOperator a, RealVector b, RealVector x0)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | SymmLQ.`solveInPlace(RealLinearOperator a, RealLinearOperator m, 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, boolean goodb, double shift)` Returns an estimate of the solution to the linear system (A - shift · I) · x = b.
    `RealVector` | SymmLQ.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x)` Returns an estimate of the solution to the linear system A · x = b.
    `abstract RealVector` | IterativeLinearSolver.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x0)` Returns an estimate of the solution to the linear system A · x = b.
    `RealVector` | PreconditionedIterativeLinearSolver.`solveInPlace(RealLinearOperator a, RealVector b, RealVector x0)` Returns an estimate of the solution to the linear system A · x = b.
    `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)` Compute `this` minus `v`.
    `FieldVector<T>` | FieldVector.`subtract(FieldVector<T> v)` Compute `this` minus `v`.
    `OpenMapRealVector` | OpenMapRealVector.`subtract(OpenMapRealVector v)` Optimized method to subtract OpenMapRealVectors.
    `RealVector` | RealVector.`subtract(RealVector v)` Subtract `v` from this vector.
    `ArrayRealVector` | ArrayRealVector.`subtract(RealVector v)` Subtract `v` from this vector.
    `RealVector` | OpenMapRealVector.`subtract(RealVector v)` Subtract `v` from this vector.
    `SparseFieldVector<T>` | SparseFieldVector.`subtract(SparseFieldVector<T> v)` Optimized method to compute `this` minus `v`.
    `static double[][]` | BlockRealMatrix.`toBlocksLayout(double[][] rawData)` Convert a data array from raw layout to blocks layout.
    `static <T extends FieldElement<T>> T[][]` | BlockFieldMatrix.`toBlocksLayout(T[][] rawData)` Convert a data array from raw layout to blocks layout.

    Constructors in org.apache.commons.math3.linear that throw DimensionMismatchException
    Constructor and Description
    `Array2DRowFieldMatrix(Field<T> field, T[][] d)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
    `Array2DRowFieldMatrix(Field<T> field, T[][] d, boolean copyArray)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
    `Array2DRowFieldMatrix(T[][] d)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
    `Array2DRowFieldMatrix(T[][] d, boolean copyArray)` Create a new `FieldMatrix<T>` using the input array as the underlying data array.
    `Array2DRowRealMatrix(double[][] d)` Create a new `RealMatrix` using the input array as the underlying data array.
    `Array2DRowRealMatrix(double[][] d, boolean copyArray)` Create a new RealMatrix using the input array as the underlying data array.
    `BlockFieldMatrix(int rows, int columns, T[][] blockData, boolean copyArray)` Create a new dense matrix copying entries from block layout data.
    `BlockFieldMatrix(T[][] rawData)` Create a new dense matrix copying entries from raw layout data.
    `BlockRealMatrix(double[][] rawData)` Create a new dense matrix copying entries from raw layout data.
    `BlockRealMatrix(int rows, int columns, double[][] blockData, boolean copyArray)` Create a new dense matrix copying entries from block layout data.

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

    Methods in org.apache.commons.math3.ode that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `protected double` | AbstractIntegrator.`acceptStep(AbstractStepInterpolator interpolator, double[] y, double[] yDot, double tEnd)` Accept a step, triggering events and step handlers.
    `void` | FirstOrderDifferentialEquations.`computeDerivatives(double t, double[] y, double[] yDot)` Get the current time derivative of the state vector.
    `void` | ExpandableStatefulODE.`computeDerivatives(double t, double[] y, double[] yDot)` Get the current time derivative of the complete state vector.
    `void` | AbstractIntegrator.`computeDerivatives(double t, double[] y, double[] yDot)` Compute the derivatives and check the number of evaluations.
    `void` | SecondaryEquations.`computeDerivatives(double t, double[] primary, double[] primaryDot, double[] secondary, double[] secondaryDot)` Compute the derivatives related to the secondary state parameters.
    `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
    Constructor and Description
    `JacobianMatrices(FirstOrderDifferentialEquations fode, double[] hY, String... parameters)` Simple constructor for a secondary equations set computing Jacobian matrices.

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

    Methods in org.apache.commons.math3.ode.nonstiff that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `double` | AdaptiveStepsizeIntegrator.`initializeStep(boolean forward, int order, double[] scale, double t0, double[] y0, double[] yDot0, double[] y1, double[] yDot1)` Initialize the integration step.
    `void` | RungeKuttaIntegrator.`integrate(ExpandableStatefulODE equations, double t)` Integrate a set of differential equations up to the given time.
    `abstract void` | AdamsIntegrator.`integrate(ExpandableStatefulODE equations, double t)` Integrate a set of differential equations up to the given time.
    `void` | AdamsMoultonIntegrator.`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` | GraggBulirschStoerIntegrator.`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.
    `protected void` | AdaptiveStepsizeIntegrator.`sanityChecks(ExpandableStatefulODE equations, double t)` Check the integration span.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Methods in org.apache.commons.math3.util that throw DimensionMismatchException
    Modifier and Type | Method and Description
    --- | ---
    `static void` | MathArrays.`checkRectangular(long[][] in)` Throws DimensionMismatchException if the input array is not rectangular.
    `static double[]` | MathArrays.`ebeAdd(double[] a, double[] b)` Creates an array whose contents will be the element-by-element addition of the arguments.
    `static double[]` | MathArrays.`ebeDivide(double[] a, double[] b)` Creates an array whose contents will be the element-by-element division of the first argument by the second.
    `static double[]` | MathArrays.`ebeMultiply(double[] a, double[] b)` Creates an array whose contents will be the element-by-element multiplication of the arguments.
    `static double[]` | MathArrays.`ebeSubtract(double[] a, double[] b)` Creates an array whose contents will be the element-by-element subtraction of the second argument from the first.
    `int` | MultidimensionalCounter.`getCount(int... c)` Convert to unidimensional counter.
    `Decimal64` | Decimal64.`linearCombination(Decimal64[] a, Decimal64[] b)` Compute a linear combination.
    `Decimal64` | Decimal64.`linearCombination(double[] a, Decimal64[] b)` Compute a linear combination.
    `static double` | MathArrays.`linearCombination(double[] a, double[] b)` Compute a linear combination accurately.
    `static void` | MathArrays.`sortInPlace(double[] x, double[]... yList)` Sort an array in ascending order in place and perform the same reordering of entries on other arrays.
    `static void` | MathArrays.`sortInPlace(double[] x, MathArrays.OrderDirection dir, double[]... yList)` Sort an array in place and perform the same reordering of entries on other arrays.

Copyright © 2003–2014 The Apache Software Foundation. All rights reserved.