| 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  functionpackage contains function objects that wrap the
      methods contained inMath, 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.ml.distance | Common distance measures. | 
| 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. | 
| 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  thisandy- 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. | 
| 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  thisandy- sqrt(this2 +y2)
 avoiding intermediate overflow or underflow. | 
| static DerivativeStructure | DerivativeStructure. hypot(DerivativeStructure x,
     DerivativeStructure y)Returns the hypotenuse of a triangle with sides  xandy- 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. | 
| 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. | 
| Modifier and Type | Method and Description | 
|---|---|
| double[] | Logit.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[] | HarmonicOscillator.Parametric. gradient(double x,
        double... param)Computes the value of the gradient at  x. | 
| double[] | Sigmoid.Parametric. gradient(double x,
        double... param)Computes the value of the gradient at  x. | 
| double[] | Gaussian.Parametric. gradient(double x,
        double... param)Computes the value of the gradient at  x. | 
| DerivativeStructure | HarmonicOscillator. value(DerivativeStructure t)Simple mathematical function. | 
| DerivativeStructure | Sigmoid. value(DerivativeStructure t)Simple mathematical function. | 
| DerivativeStructure | Gaussian. value(DerivativeStructure t)Simple mathematical function. | 
| DerivativeStructure | Sinc. value(DerivativeStructure t)Simple mathematical function. | 
| double | Logit.Parametric. value(double x,
     double... param)Computes the value of the logit at  x. | 
| double | Logistic.Parametric. value(double x,
     double... param)Computes the value of the sigmoid at  x. | 
| double | HarmonicOscillator.Parametric. value(double x,
     double... param)Computes the value of the harmonic oscillator at  x. | 
| double | Sigmoid.Parametric. value(double x,
     double... param)Computes the value of the sigmoid at  x. | 
| double | Gaussian.Parametric. value(double x,
     double... param)Computes the value of the Gaussian at  x. | 
| Constructor and Description | 
|---|
| StepFunction(double[] x,
            double[] y)Builds a step function from a list of arguments and the corresponding
 values. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected void | BaseRuleFactory. addRule(Pair<T[],T[]> rule)Stores a rule. | 
| 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. | 
| protected Pair<Double[],Double[]> | HermiteRuleFactory. computeRule(int numberOfPoints)Computes the rule for the given order. | 
| protected abstract Pair<T[],T[]> | BaseRuleFactory. 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. | 
| Constructor and Description | 
|---|
| GaussIntegrator(double[] points,
               double[] weights)Creates an integrator from the given  pointsandweights. | 
| SymmetricGaussIntegrator(double[] points,
                        double[] weights)Creates an integrator from the given  pointsandweights. | 
| 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 | MultivariateInterpolator. interpolate(double[][] xval,
           double[] yval)Computes an interpolating function for the data set. | 
| MultivariateFunction | MicrosphereInterpolator. interpolate(double[][] xval,
           double[] yval)Deprecated.  Computes an interpolating function for the data set. | 
| MultivariateFunction | MicrosphereProjectionInterpolator. interpolate(double[][] xval,
           double[] yval)Computes an interpolating function for the data set. | 
| PolynomialSplineFunction | LinearInterpolator. interpolate(double[] x,
           double[] y)Computes a linear interpolating function for the data set. | 
| UnivariateFunction | UnivariateInterpolator. interpolate(double[] xval,
           double[] yval)Compute an interpolating function for the dataset. | 
| PolynomialFunctionLagrangeForm | NevilleInterpolator. interpolate(double[] x,
           double[] y)Computes an interpolating function for the data set. | 
| PolynomialSplineFunction | AkimaSplineInterpolator. interpolate(double[] xvals,
           double[] yvals)Computes an interpolating function for the data set. | 
| PolynomialSplineFunction | SplineInterpolator. interpolate(double[] x,
           double[] y)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
  SplineInterpolatoron the resulting fit. | 
| BicubicSplineInterpolatingFunction | SmoothingPolynomialBicubicSplineInterpolator. interpolate(double[] xval,
           double[] yval,
           double[][] fval)Deprecated.  Compute an interpolating function for the dataset. | 
| BicubicInterpolatingFunction | BicubicInterpolator. interpolate(double[] xval,
           double[] yval,
           double[][] fval)Compute an interpolating function for the dataset. | 
| BicubicSplineInterpolatingFunction | BicubicSplineInterpolator. interpolate(double[] xval,
           double[] yval,
           double[][] fval)Deprecated.  Compute an interpolating function for the dataset. | 
| PiecewiseBicubicSplineInterpolatingFunction | PiecewiseBicubicSplineInterpolator. interpolate(double[] xval,
           double[] yval,
           double[][] fval)Compute an interpolating function for the dataset. | 
| BivariateFunction | BivariateGridInterpolator. interpolate(double[] xval,
           double[] yval,
           double[][] fval)Compute an interpolating function for the dataset. | 
| TricubicInterpolatingFunction | TricubicInterpolator. interpolate(double[] xval,
           double[] yval,
           double[] zval,
           double[][][] fval)Compute an interpolating function for the dataset. | 
| TrivariateFunction | TrivariateGridInterpolator. interpolate(double[] xval,
           double[] yval,
           double[] zval,
           double[][][] fval)Compute an interpolating function for the dataset. | 
| TricubicSplineInterpolatingFunction | TricubicSplineInterpolator. interpolate(double[] xval,
           double[] yval,
           double[] zval,
           double[][][] fval)Deprecated.  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)Deprecated.  | 
| Constructor and Description | 
|---|
| BicubicInterpolatingFunction(double[] x,
                            double[] y,
                            double[][] f,
                            double[][] dFdX,
                            double[][] dFdY,
                            double[][] d2FdXdY) | 
| BicubicSplineInterpolatingFunction(double[] x,
                                  double[] y,
                                  double[][] f,
                                  double[][] dFdX,
                                  double[][] dFdY,
                                  double[][] d2FdXdY)Deprecated.  | 
| BicubicSplineInterpolatingFunction(double[] x,
                                  double[] y,
                                  double[][] f,
                                  double[][] dFdX,
                                  double[][] dFdY,
                                  double[][] d2FdXdY,
                                  boolean initializeDerivatives)Deprecated.  | 
| MicrosphereInterpolatingFunction(double[][] xval,
                                double[] yval,
                                int brightnessExponent,
                                int microsphereElements,
                                UnitSphereRandomVectorGenerator rand)Deprecated.  | 
| PiecewiseBicubicSplineInterpolatingFunction(double[] x,
                                           double[] y,
                                           double[][] f) | 
| TricubicInterpolatingFunction(double[] x,
                             double[] y,
                             double[] z,
                             double[][][] f,
                             double[][][] dFdX,
                             double[][][] dFdY,
                             double[][][] dFdZ,
                             double[][][] d2FdXdY,
                             double[][][] d2FdXdZ,
                             double[][][] d2FdYdZ,
                             double[][][] d3FdXdYdZ) | 
| TricubicSplineInterpolatingFunction(double[] x,
                                   double[] y,
                                   double[] z,
                                   double[][][] f,
                                   double[][][] dFdX,
                                   double[][][] dFdY,
                                   double[][][] dFdZ,
                                   double[][][] d2FdXdY,
                                   double[][][] d2FdXdZ,
                                   double[][][] d2FdYdZ,
                                   double[][][] d3FdXdYdZ)Deprecated.  | 
| Modifier and Type | Method and Description | 
|---|---|
| static double | PolynomialFunctionLagrangeForm. evaluate(double[] x,
        double[] y,
        double z)Evaluate the Lagrange polynomial using
 
 Neville's Algorithm. | 
| static double | PolynomialFunctionNewtonForm. evaluate(double[] a,
        double[] c,
        double z)Evaluate the Newton polynomial using nested multiplication. | 
| protected static void | PolynomialFunctionNewtonForm. verifyInputArray(double[] a,
                double[] c)Verifies that the input arrays are valid. | 
| static boolean | PolynomialFunctionLagrangeForm. verifyInterpolationArray(double[] x,
                        double[] y,
                        boolean abort)Check that the interpolation arrays are valid. | 
| 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. | 
| Constructor and Description | 
|---|
| Quaternion(double scalar,
          double[] v)Builds a quaternion from scalar and vector parts. | 
| 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. | 
| 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. | 
| 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 real-valued distribution using the given probability mass function
 enumeration. | 
| EnumeratedRealDistribution(RandomGenerator rng,
                          double[] singletons,
                          double[] probabilities)Create a discrete real-valued 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. | 
| 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. | 
| Constructor and Description | 
|---|
| MultivariateNormalMixtureExpectationMaximization(double[][] data)Creates an object to fit a multivariate normal mixture model to data. | 
| 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. | 
| 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. | 
| Modifier and Type | Method and Description | 
|---|---|
| ChromosomePair | OnePointCrossover. crossover(Chromosome first,
         Chromosome second)Performs one point crossover. | 
| ChromosomePair | CycleCrossover. crossover(Chromosome first,
         Chromosome second)Perform a crossover operation on the given chromosomes. | 
| ChromosomePair | NPointCrossover. crossover(Chromosome first,
         Chromosome second)Performs a N-point crossover. | 
| ChromosomePair | OrderedCrossover. crossover(Chromosome first,
         Chromosome second)Perform a crossover operation on the given chromosomes. | 
| ChromosomePair | UniformCrossover. crossover(Chromosome first,
         Chromosome second)Perform a crossover operation on the given chromosomes. | 
| static <S> List<Double> | RandomKey. inducedPermutation(List<S> originalData,
                  List<S> permutedData)Generates a representation of a permutation corresponding to a
 permutation which yields  permutedDatawhen applied tooriginalData. | 
| 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) | 
| Constructor and Description | 
|---|
| FieldVector3D(T[] v)Simple constructor. | 
| Vector3D(double[] v)Simple constructor. | 
| Constructor and Description | 
|---|
| Vector2D(double[] v)Simple constructor. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | NonSquareMatrixExceptionException to be thrown when a square matrix is expected. | 
| class  | NonSquareOperatorExceptionException to be thrown when a square linear operator is expected. | 
| Modifier and Type | Method and Description | 
|---|---|
| ArrayFieldVector<T> | ArrayFieldVector. add(ArrayFieldVector<T> v)Compute the sum of  thisandv. | 
| FieldVector<T> | FieldVector. add(FieldVector<T> v)Compute the sum of  thisandv. | 
| FieldVector<T> | SparseFieldVector. add(FieldVector<T> v)Compute the sum of  thisandv. | 
| FieldVector<T> | ArrayFieldVector. add(FieldVector<T> v)Compute the sum of  thisandv. | 
| OpenMapRealVector | OpenMapRealVector. add(OpenMapRealVector v)Optimized method to add two OpenMapRealVectors. | 
| RealVector | RealVector. add(RealVector v)Compute the sum of this vector and  v. | 
| RealVector | OpenMapRealVector. add(RealVector v)Compute the sum of this vector and  v. | 
| ArrayRealVector | ArrayRealVector. add(RealVector v)Compute the sum of this vector and  v. | 
| FieldVector<T> | SparseFieldVector. add(SparseFieldVector<T> v)Optimized method to add sparse vectors. | 
| 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
  solveandsolveInPlace,
 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
  solveandsolveInPlace,
 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 | 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 | SparseFieldVector. checkVectorDimensions(int n)Check if instance dimension is equal to some expected value. | 
| protected void | ArrayFieldVector. 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 ofthisandy. | 
| ArrayRealVector | ArrayRealVector. combine(double a,
       double b,
       RealVector y)Returns a new vector representing  a * this + b * y, the linear
 combination ofthisandy. | 
| RealVector | RealVector. combineToSelf(double a,
             double b,
             RealVector y)Updates  thiswith the linear combination ofthisandy. | 
| ArrayRealVector | ArrayRealVector. combineToSelf(double a,
             double b,
             RealVector y)Updates  thiswith the linear combination ofthisandy. | 
| double | RealVector. cosine(RealVector v)Computes the cosine of the angle between this vector and the
 argument. | 
| static <T extends FieldElement<T>>  | MatrixUtils. createFieldMatrix(T[][] data)Returns a  FieldMatrixwhose 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  RealMatrixwhose entries are the the values in the
 the input array. | 
| T | ArrayFieldVector. dotProduct(ArrayFieldVector<T> v)Compute the dot product. | 
| T | FieldVector. dotProduct(FieldVector<T> v)Compute the dot product. | 
| T | SparseFieldVector. dotProduct(FieldVector<T> v)Compute the dot product. | 
| T | ArrayFieldVector. 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> | FieldVector. ebeDivide(FieldVector<T> v)Element-by-element division. | 
| FieldVector<T> | SparseFieldVector. ebeDivide(FieldVector<T> v)Element-by-element division. | 
| FieldVector<T> | ArrayFieldVector. ebeDivide(FieldVector<T> v)Element-by-element division. | 
| abstract RealVector | RealVector. ebeDivide(RealVector v)Element-by-element division. | 
| OpenMapRealVector | OpenMapRealVector. ebeDivide(RealVector v)Element-by-element division. | 
| ArrayRealVector | ArrayRealVector. ebeDivide(RealVector v)Element-by-element division. | 
| ArrayFieldVector<T> | ArrayFieldVector. ebeMultiply(ArrayFieldVector<T> v)Element-by-element multiplication. | 
| FieldVector<T> | FieldVector. ebeMultiply(FieldVector<T> v)Element-by-element multiplication. | 
| FieldVector<T> | SparseFieldVector. ebeMultiply(FieldVector<T> v)Element-by-element multiplication. | 
| FieldVector<T> | ArrayFieldVector. ebeMultiply(FieldVector<T> v)Element-by-element multiplication. | 
| abstract RealVector | RealVector. ebeMultiply(RealVector v)Element-by-element multiplication. | 
| OpenMapRealVector | OpenMapRealVector. ebeMultiply(RealVector v)Element-by-element multiplication. | 
| ArrayRealVector | ArrayRealVector. ebeMultiply(RealVector v)Element-by-element multiplication. | 
| double | OpenMapRealVector. getDistance(OpenMapRealVector v)Optimized method to compute distance. | 
| double | RealVector. getDistance(RealVector v)Distance between two vectors. | 
| double | OpenMapRealVector. getDistance(RealVector v)Distance between two vectors. | 
| double | ArrayRealVector. getDistance(RealVector v)Distance between two vectors. | 
| double | OpenMapRealVector. getL1Distance(OpenMapRealVector v)Distance between two vectors. | 
| double | RealVector. getL1Distance(RealVector v)Distance between two vectors. | 
| double | OpenMapRealVector. getL1Distance(RealVector v)Distance between two vectors. | 
| double | ArrayRealVector. getL1Distance(RealVector v)Distance between two vectors. | 
| double | RealVector. getLInfDistance(RealVector v)Distance between two vectors. | 
| double | OpenMapRealVector. getLInfDistance(RealVector v)Distance between two vectors. | 
| double | ArrayRealVector. getLInfDistance(RealVector v)Distance between two vectors. | 
| Array2DRowFieldMatrix<T> | Array2DRowFieldMatrix. multiply(Array2DRowFieldMatrix<T> m)Postmultiplying this matrix by  m. | 
| Array2DRowRealMatrix | Array2DRowRealMatrix. multiply(Array2DRowRealMatrix m)Returns the result of postmultiplying  thisbym. | 
| BlockFieldMatrix<T> | BlockFieldMatrix. multiply(BlockFieldMatrix<T> m)Returns the result of postmultiplying  thisbym. | 
| BlockRealMatrix | BlockRealMatrix. multiply(BlockRealMatrix m)Returns the result of postmultiplying this by  m. | 
| DiagonalMatrix | DiagonalMatrix. multiply(DiagonalMatrix m)Returns the result of postmultiplying  thisbym. | 
| FieldMatrix<T> | AbstractFieldMatrix. multiply(FieldMatrix<T> m)Postmultiply this matrix by  m. | 
| FieldMatrix<T> | BlockFieldMatrix. multiply(FieldMatrix<T> m)Postmultiply this matrix by  m. | 
| FieldMatrix<T> | FieldMatrix. multiply(FieldMatrix<T> m)Postmultiply this matrix by  m. | 
| OpenMapRealMatrix | OpenMapRealMatrix. multiply(OpenMapRealMatrix m)Postmultiply this matrix by  m. | 
| RealMatrix | DiagonalMatrix. multiply(RealMatrix m)Returns the result of postmultiplying  thisbym. | 
| BlockRealMatrix | BlockRealMatrix. multiply(RealMatrix m)Returns the result of postmultiplying  thisbym. | 
| RealMatrix | AbstractRealMatrix. multiply(RealMatrix m)Returns the result of postmultiplying  thisbym. | 
| RealMatrix | RealMatrix. multiply(RealMatrix m)Returns the result of postmultiplying  thisbym. | 
| RealMatrix | OpenMapRealMatrix. multiply(RealMatrix m)Returns the result of postmultiplying  thisbym. | 
| double[] | DiagonalMatrix. operate(double[] v)Returns the result of multiplying this by the vector  v. | 
| double[] | BlockRealMatrix. operate(double[] v)Returns the result of multiplying this by the vector  v. | 
| double[] | 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. | 
| double[] | Array2DRowRealMatrix. operate(double[] v)Returns the result of multiplying this by the vector  v. | 
| FieldVector<T> | AbstractFieldMatrix. operate(FieldVector<T> v)Returns the result of multiplying this by the vector  v. | 
| FieldVector<T> | FieldMatrix. operate(FieldVector<T> v)Returns the result of multiplying this by the vector  v. | 
| abstract RealVector | RealLinearOperator. operate(RealVector x)Returns the result of multiplying  thisby the vectorx. | 
| RealVector | AbstractRealMatrix. operate(RealVector v)Returns the result of multiplying  thisby the vectorx. | 
| RealVector | RealMatrix. operate(RealVector 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. | 
| T[] | FieldMatrix. 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  thisoperator
 by the vectorx(optional operation). | 
| double[] | DiagonalMatrix. preMultiply(double[] v)Returns the (row) vector result of premultiplying this by the vector  v. | 
| double[] | BlockRealMatrix. preMultiply(double[] v)Returns the (row) vector result of premultiplying this by the vector  v. | 
| double[] | 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. | 
| double[] | Array2DRowRealMatrix. preMultiply(double[] v)Returns the (row) vector result of premultiplying this by the vector  v. | 
| FieldMatrix<T> | AbstractFieldMatrix. preMultiply(FieldMatrix<T> m)Premultiply this matrix by  m. | 
| FieldMatrix<T> | FieldMatrix. preMultiply(FieldMatrix<T> m)Premultiply this matrix by  m. | 
| FieldVector<T> | AbstractFieldMatrix. preMultiply(FieldVector<T> v)Returns the (row) vector result of premultiplying this by the vector
  v. | 
| FieldVector<T> | FieldMatrix. preMultiply(FieldVector<T> v)Returns the (row) vector result of premultiplying this by the vector
  v. | 
| RealMatrix | AbstractRealMatrix. preMultiply(RealMatrix m)Returns the result of premultiplying  thisbym. | 
| RealMatrix | RealMatrix. preMultiply(RealMatrix m)Returns the result of premultiplying  thisbym. | 
| 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[] | 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. | 
| T[] | FieldMatrix. 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> | FieldVector. projection(FieldVector<T> v)Find the orthogonal projection of this vector onto another vector. | 
| FieldVector<T> | SparseFieldVector. projection(FieldVector<T> v)Find the orthogonal projection of this vector onto another vector. | 
| FieldVector<T> | ArrayFieldVector. projection(FieldVector<T> v)Find the orthogonal projection of this vector onto another vector. | 
| RealVector | RealVector. projection(RealVector v)Find the orthogonal projection of this vector onto another vector. | 
| void | BlockRealMatrix. setSubMatrix(double[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  row, columnusing data in the
 inputsubMatrixarray. | 
| void | AbstractRealMatrix. setSubMatrix(double[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  row, columnusing data in the
 inputsubMatrixarray. | 
| void | RealMatrix. setSubMatrix(double[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  row, columnusing data in the
 inputsubMatrixarray. | 
| void | Array2DRowRealMatrix. setSubMatrix(double[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  row, columnusing data in the
 inputsubMatrixarray. | 
| void | Array2DRowFieldMatrix. setSubMatrix(T[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  (row, column)using data in the
 inputsubMatrixarray. | 
| void | AbstractFieldMatrix. setSubMatrix(T[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  (row, column)using data in the
 inputsubMatrixarray. | 
| void | BlockFieldMatrix. setSubMatrix(T[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  (row, column)using data in the
 inputsubMatrixarray. | 
| void | FieldMatrix. setSubMatrix(T[][] subMatrix,
            int row,
            int column)Replace the submatrix starting at  (row, column)using data in the
 inputsubMatrixarray. | 
| 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  thisminusv. | 
| FieldVector<T> | FieldVector. subtract(FieldVector<T> v)Compute  thisminusv. | 
| FieldVector<T> | SparseFieldVector. subtract(FieldVector<T> v)Compute  thisminusv. | 
| FieldVector<T> | ArrayFieldVector. subtract(FieldVector<T> v)Compute  thisminusv. | 
| OpenMapRealVector | OpenMapRealVector. subtract(OpenMapRealVector v)Optimized method to subtract OpenMapRealVectors. | 
| RealVector | RealVector. subtract(RealVector v)Subtract  vfrom this vector. | 
| RealVector | OpenMapRealVector. subtract(RealVector v)Subtract  vfrom this vector. | 
| ArrayRealVector | ArrayRealVector. subtract(RealVector v)Subtract  vfrom this vector. | 
| SparseFieldVector<T> | SparseFieldVector. subtract(SparseFieldVector<T> v)Optimized method to compute  thisminusv. | 
| static double[][] | BlockRealMatrix. toBlocksLayout(double[][] rawData)Convert a data array from raw layout to blocks layout. | 
| static <T extends FieldElement<T>>  | BlockFieldMatrix. toBlocksLayout(T[][] rawData)Convert a data array from raw layout to blocks layout. | 
| 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  RealMatrixusing 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. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | ChebyshevDistance. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| double | ManhattanDistance. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| double | CanberraDistance. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| double | DistanceMeasure. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| double | EuclideanDistance. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| double | EarthMoversDistance. compute(double[] a,
       double[] b)Compute the distance between two n-dimensional vectors. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected FieldODEStateAndDerivative<T> | AbstractFieldIntegrator. acceptStep(AbstractFieldStepInterpolator<T> interpolator,
          T tEnd)Accept a step, triggering events and step handlers. | 
| protected double | AbstractIntegrator. acceptStep(AbstractStepInterpolator interpolator,
          double[] y,
          double[] yDot,
          double tEnd)Accept a step, triggering events and step handlers. | 
| void | 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. | 
| T[] | AbstractFieldIntegrator. computeDerivatives(T t,
                  T[] y)Compute the derivatives and check the number of evaluations. | 
| T[] | FieldExpandableODE. computeDerivatives(T t,
                  T[] y)Get the current time derivative of the complete state vector. | 
| T[] | FieldSecondaryEquations. computeDerivatives(T t,
                  T[] primary,
                  T[] primaryDot,
                  T[] secondary)Compute the derivatives related to the secondary state parameters. | 
| void | MainStateJacobianProvider. computeMainStateJacobian(double t,
                        double[] y,
                        double[] yDot,
                        double[][] dFdY)Compute the jacobian matrix of ODE with respect to main state. | 
| void | ParameterJacobianProvider. computeParameterJacobian(double t,
                        double[] y,
                        double[] yDot,
                        String paramName,
                        double[] dFdP)Compute the Jacobian matrix of ODE with respect to one parameter. | 
| void | EquationsMapper. extractEquationData(double[] complete,
                   double[] equationData)Extract equation data from a complete state or derivative array. | 
| T[] | FieldEquationsMapper. extractEquationData(int index,
                   T[] complete)Extract equation data from a complete state or derivative array. | 
| double[] | ExpandableStatefulODE. getCompleteState()Get the complete current state. | 
| void | EquationsMapper. insertEquationData(double[] equationData,
                  double[] complete)Insert equation data into a complete state or derivative array. | 
| void | FieldEquationsMapper. insertEquationData(int index,
                  T[] equationData,
                  T[] complete)Insert equation data into a complete state or derivative array. | 
| abstract void | AbstractIntegrator. integrate(ExpandableStatefulODE equations,
         double t)Integrate a set of differential equations up to the given time. | 
| double | FirstOrderIntegrator. integrate(FirstOrderDifferentialEquations equations,
         double t0,
         double[] y0,
         double t,
         double[] y)Integrate the 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. | 
| FieldODEStateAndDerivative<T> | FieldEquationsMapper. mapStateAndDerivative(T t,
                     T[] y,
                     T[] yDot)Map flat arrays to a state and derivative. | 
| void | JacobianMatrices. registerVariationalEquations(ExpandableStatefulODE expandable)Register the variational equations for the Jacobians matrices to the expandable set. | 
| protected void | AbstractIntegrator. sanityChecks(ExpandableStatefulODE equations,
            double t)Check the integration span. | 
| protected void | AbstractFieldIntegrator. sanityChecks(FieldODEState<T> eqn,
            T t)Check the integration span. | 
| void | ExpandableStatefulODE. setCompleteState(double[] completeState)Set the complete current state. | 
| void | JacobianMatrices. setInitialMainStateJacobian(double[][] dYdY0)Set the initial value of the Jacobian matrix with respect to state. | 
| void | JacobianMatrices. setInitialParameterJacobian(String pName,
                           double[] dYdP)Set the initial value of a column of the Jacobian matrix with respect to one parameter. | 
| void | ExpandableStatefulODE. setPrimaryState(double[] primaryState)Set primary part of the current state. | 
| void | ExpandableStatefulODE. setSecondaryState(int index,
                 double[] secondaryState)Set secondary part of the current state. | 
| protected void | MultistepIntegrator. start(double t0,
     double[] y0,
     double t)Start the integration. | 
| protected void | MultistepFieldIntegrator. start(FieldExpandableODE<T> equations,
     FieldODEState<T> initialState,
     T t)Start the integration. | 
| Constructor and Description | 
|---|
| JacobianMatrices(FirstOrderDifferentialEquations fode,
                double[] hY,
                String... parameters)Simple constructor for a secondary equations set computing Jacobian matrices. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | AdaptiveStepsizeIntegrator. initializeStep(boolean forward,
              int order,
              double[] scale,
              double t0,
              double[] y0,
              double[] yDot0,
              double[] y1,
              double[] yDot1)Initialize the integration step. | 
| T | AdaptiveStepsizeFieldIntegrator. initializeStep(boolean forward,
              int order,
              T[] scale,
              FieldODEStateAndDerivative<T> state0,
              FieldEquationsMapper<T> mapper)Initialize the integration step. | 
| abstract void | AdamsIntegrator. 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 | 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 | AdamsBashforthIntegrator. integrate(ExpandableStatefulODE equations,
         double t)Integrate a set of differential equations up to the given time. | 
| void | RungeKuttaIntegrator. integrate(ExpandableStatefulODE equations,
         double t)Integrate a set of differential equations up to the given time. | 
| void | GraggBulirschStoerIntegrator. integrate(ExpandableStatefulODE equations,
         double t)Integrate a set of differential equations up to the given time. | 
| FieldODEStateAndDerivative<T> | RungeKuttaFieldIntegrator. integrate(FieldExpandableODE<T> equations,
         FieldODEState<T> initialState,
         T finalTime)Integrate the differential equations up to the given time. | 
| FieldODEStateAndDerivative<T> | EmbeddedRungeKuttaFieldIntegrator. integrate(FieldExpandableODE<T> equations,
         FieldODEState<T> initialState,
         T finalTime)Integrate the differential equations up to the given time. | 
| FieldODEStateAndDerivative<T> | AdamsBashforthFieldIntegrator. integrate(FieldExpandableODE<T> equations,
         FieldODEState<T> initialState,
         T finalTime)Integrate the differential equations up to the given time. | 
| FieldODEStateAndDerivative<T> | AdamsMoultonFieldIntegrator. integrate(FieldExpandableODE<T> equations,
         FieldODEState<T> initialState,
         T finalTime)Integrate the differential equations up to the given time. | 
| abstract FieldODEStateAndDerivative<T> | AdamsFieldIntegrator. integrate(FieldExpandableODE<T> equations,
         FieldODEState<T> initialState,
         T finalTime)Integrate the differential equations up to the given time. | 
| protected void | AdaptiveStepsizeIntegrator. sanityChecks(ExpandableStatefulODE equations,
            double t)Check the integration span. | 
| protected void | AdaptiveStepsizeFieldIntegrator. sanityChecks(FieldODEState<T> eqn,
            T t)Check the integration span. | 
| Modifier and Type | Method and Description | 
|---|---|
| PointValuePair | CMAESOptimizer. optimize(OptimizationData... optData)Stores data and performs the optimization. | 
| Modifier and Type | Method and Description | 
|---|---|
| PointVectorValuePair | MultivariateVectorOptimizer. optimize(OptimizationData... optData)Deprecated.  Stores data and performs the optimization. | 
| PointVectorValuePair | JacobianMultivariateVectorOptimizer. optimize(OptimizationData... optData)Deprecated.  Stores data and performs the optimization. | 
| 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. | 
| 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. | 
| 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]). | 
| Modifier and Type | Method and Description | 
|---|---|
| void | StorelessCovariance. append(StorelessCovariance sc)Appends  scto this, effectively aggregating the computations inscwith 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. | 
| 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. | 
| 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. | 
| 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. | 
| static double | TestUtils. chiSquare(double[] expected,
         long[] observed) | 
| double | ChiSquareTest. chiSquare(double[] expected,
         long[] observed) | 
| 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  countsarray, 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  observed1andobserved2. | 
| 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  observedfrequency counts to those in theexpectedarray. | 
| 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  countsarray, 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  observed1andobserved2. | 
| 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) | 
| 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
  observed1andobserved2. | 
| 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
  observedfrequency counts to those in theexpectedarray. | 
| 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  observed1andobserved2. | 
| 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  sample1andsample2is 0 in favor of the two-sided alternative that the
 mean paired difference is not equal to 0, with significance levelalpha. | 
| 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. | 
| Modifier and Type | Method and Description | 
|---|---|
| static Complex[] | TransformUtils. createComplexArray(double[][] dataRI)Builds a new array of  Complexfrom the specified two dimensional
 array of real and imaginary parts. | 
| Modifier and Type | Method and Description | 
|---|---|
| static void | MathArrays. checkRectangular(long[][] in)Throws DimensionMismatchException if the input array is not rectangular. | 
| static double | MathArrays. distance(double[] p1,
        double[] p2)Calculates the L2 (Euclidean) distance between two points. | 
| static double | MathArrays. distance(int[] p1,
        int[] p2)Calculates the L2 (Euclidean) distance between two points. | 
| static double | MathArrays. distance1(double[] p1,
         double[] p2)Calculates the L1 (sum of abs) distance between two points. | 
| static int | MathArrays. distance1(int[] p1,
         int[] p2)Calculates the L1 (sum of abs) distance between two points. | 
| static double | MathArrays. distanceInf(double[] p1,
           double[] p2)Calculates the L∞ (max of abs) distance between two points. | 
| static int | MathArrays. distanceInf(int[] p1,
           int[] p2)Calculates the L∞ (max of abs) distance between two points. | 
| static double[] | MathArrays. ebeAdd(double[] a,
      double[] b)Creates an array whose contents will be the element-by-element
 addition of the arguments. | 
| static double[] | MathArrays. ebeDivide(double[] a,
         double[] b)Creates an array whose contents will be the element-by-element
 division of the first argument by the second. | 
| static double[] | MathArrays. ebeMultiply(double[] a,
           double[] b)Creates an array whose contents will be the element-by-element
 multiplication of the arguments. | 
| static double[] | MathArrays. ebeSubtract(double[] a,
           double[] b)Creates an array whose contents will be the element-by-element
 subtraction of the second argument from the first. | 
| 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–2016 The Apache Software Foundation. All rights reserved.