| Package | Description | 
|---|---|
| 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.integration | Numerical integration (quadrature) algorithms for univariate real functions. | 
| org.apache.commons.math3.analysis.interpolation | Univariate real functions interpolation algorithms. | 
| org.apache.commons.math3.analysis.solvers | Root finding algorithms, for univariate real functions. | 
| org.apache.commons.math3.complex | Complex number type and implementations of complex transcendental
     functions. | 
| org.apache.commons.math3.exception | Specialized exceptions for algorithms errors. | 
| org.apache.commons.math3.fraction | Fraction number type and fraction number formatting. | 
| 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.geometry.euclidean.twod.hull | 
 This package provides algorithms to generate the convex hull
 for a set of points in an two-dimensional euclidean space. | 
| org.apache.commons.math3.geometry.spherical.oned | 
 This package provides basic geometry components on the 1-sphere. | 
| org.apache.commons.math3.linear | Linear algebra support. | 
| org.apache.commons.math3.ml.clustering | Clustering algorithms. | 
| org.apache.commons.math3.ode | 
 This package provides classes to solve Ordinary Differential Equations problems. | 
| org.apache.commons.math3.random | Random number and random data generators. | 
| org.apache.commons.math3.special | Implementations of special functions such as Beta and Gamma. | 
| org.apache.commons.math3.stat | Data storage, manipulation and summary routines. | 
| org.apache.commons.math3.stat.clustering | All classes and sub-packages of this package are deprecated. | 
| 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.descriptive.rank | Summary statistics based on ranks. | 
| org.apache.commons.math3.stat.descriptive.summary | Other summary statistics. | 
| org.apache.commons.math3.stat.inference | Classes providing hypothesis testing. | 
| org.apache.commons.math3.stat.regression | Statistical routines involving multivariate data. | 
| 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 | 
|---|---|
| DerivativeStructure[][] | UnivariateDifferentiableMatrixFunction. value(DerivativeStructure x)Compute the value for the function. | 
| DerivativeStructure[] | UnivariateDifferentiableVectorFunction. value(DerivativeStructure x)Compute the value for the function. | 
| DerivativeStructure[] | MultivariateDifferentiableVectorFunction. value(DerivativeStructure[] point)Compute the value for the function at the given point. | 
| DerivativeStructure | MultivariateDifferentiableFunction. value(DerivativeStructure[] point)Compute the value for the function at the given point. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected double | IterativeLegendreGaussIntegrator. doIntegrate()Method for implementing actual integration algorithms in derived
 classes. | 
| protected double | TrapezoidIntegrator. doIntegrate()Method for implementing actual integration algorithms in derived
 classes. | 
| protected double | LegendreGaussIntegrator. doIntegrate()Deprecated.  Method for implementing actual integration algorithms in derived
 classes. | 
| protected double | MidPointIntegrator. doIntegrate()Method for implementing actual integration algorithms in derived
 classes. | 
| double | UnivariateIntegrator. integrate(int maxEval,
         UnivariateFunction f,
         double min,
         double max)Integrate the function in the given interval. | 
| double | BaseAbstractUnivariateIntegrator. integrate(int maxEval,
         UnivariateFunction f,
         double lower,
         double upper)Integrate the function in the given interval. | 
| protected void | BaseAbstractUnivariateIntegrator. setup(int maxEval,
     UnivariateFunction f,
     double lower,
     double upper)Prepare for computation. | 
| Constructor and Description | 
|---|
| LegendreGaussIntegrator(int n,
                       double relativeAccuracy,
                       double absoluteAccuracy)Deprecated.  Build a Legendre-Gauss integrator with given accuracies. | 
| LegendreGaussIntegrator(int n,
                       double relativeAccuracy,
                       double absoluteAccuracy,
                       int minimalIterationCount,
                       int maximalIterationCount)Deprecated.  Build a Legendre-Gauss integrator with given accuracies and iterations counts. | 
| LegendreGaussIntegrator(int n,
                       int minimalIterationCount,
                       int maximalIterationCount)Deprecated.  Build a Legendre-Gauss integrator with given iteration counts. | 
| Modifier and Type | Method and Description | 
|---|---|
| MultivariateFunction | MultivariateInterpolator. interpolate(double[][] xval,
           double[] yval)Computes an interpolating function for the data set. | 
| UnivariateFunction | UnivariateInterpolator. interpolate(double[] xval,
           double[] yval)Compute an interpolating function for the dataset. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | BaseUnivariateSolver. solve(int maxEval,
     FUNC f,
     double min,
     double max)Solve for a zero root in the given interval. | 
| double | BaseUnivariateSolver. solve(int maxEval,
     FUNC f,
     double min,
     double max,
     double startValue)Solve for a zero in the given interval, start at  startValue. | 
| Modifier and Type | Method and Description | 
|---|---|
| StringBuffer | ComplexFormat. format(Object obj,
      StringBuffer toAppendTo,
      FieldPosition pos)Formats a object to produce a string. | 
| double | RootsOfUnity. getReal(int k)Get the real part of the  k-thn-th root of unity. | 
| static Complex | ComplexUtils. polar2Complex(double r,
             double theta)Creates a complex number from the given polar representation. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | DimensionMismatchExceptionException to be thrown when two dimensions differ. | 
| class  | InsufficientDataExceptionException to be thrown when there is insufficient data to perform a computation. | 
| class  | MathIllegalNumberExceptionBase class for exceptions raised by a wrong number. | 
| class  | MultiDimensionMismatchExceptionException to be thrown when two sets of dimensions differ. | 
| class  | NoBracketingExceptionException to be thrown when function values have the same sign at both
 ends of an interval. | 
| class  | NoDataExceptionException to be thrown when the required data is missing. | 
| class  | NonMonotonicSequenceExceptionException to be thrown when the a sequence of values is not monotonically
 increasing or decreasing. | 
| class  | NotANumberExceptionException to be thrown when a number is not a number. | 
| class  | NotFiniteNumberExceptionException to be thrown when a number is not finite. | 
| class  | NotPositiveExceptionException to be thrown when the argument is negative. | 
| class  | NotStrictlyPositiveExceptionException to be thrown when the argument is not greater than 0. | 
| class  | NullArgumentExceptionAll conditions checks that fail due to a  nullargument must throw
 this exception. | 
| class  | NumberIsTooLargeExceptionException to be thrown when a number is too large. | 
| class  | NumberIsTooSmallExceptionException to be thrown when a number is too small. | 
| class  | OutOfRangeExceptionException to be thrown when some argument is out of range. | 
| class  | ZeroExceptionException to be thrown when zero is provided where it is not allowed. | 
| Modifier and Type | Method and Description | 
|---|---|
| StringBuffer | FractionFormat. format(Object obj,
      StringBuffer toAppendTo,
      FieldPosition pos)Formats an object and appends the result to a StringBuffer. | 
| Constructor and Description | 
|---|
| BigFraction(double value)Create a fraction given the double value. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | InvalidRepresentationExceptionException indicating that the representation of a chromosome is not valid. | 
| Modifier and Type | Method and Description | 
|---|---|
| ChromosomePair | OnePointCrossover. crossover(Chromosome first,
         Chromosome second)Performs one point crossover. | 
| ChromosomePair | CrossoverPolicy. 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. | 
| 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. | 
| Chromosome | BinaryMutation. mutate(Chromosome original)Mutate the given chromosome. | 
| Chromosome | MutationPolicy. mutate(Chromosome original)Mutate the given chromosome. | 
| Chromosome | RandomKeyMutation. mutate(Chromosome original)Mutate the given chromosome. | 
| ChromosomePair | SelectionPolicy. select(Population population)Select two chromosomes from the population. | 
| ChromosomePair | TournamentSelection. select(Population population)Select two chromosomes from the population. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | NotARotationMatrixExceptionThis class represents exceptions thrown while building rotations
 from matrices. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | Line. reset(Vector3D p1,
     Vector3D p2)Reset the instance as if built from two points. | 
| Constructor and Description | 
|---|
| FieldRotation(FieldVector3D<T> axis,
             T angle)Deprecated. 
 as of 3.6, replaced with  FieldRotation.FieldRotation(FieldVector3D, RealFieldElement, RotationConvention) | 
| FieldRotation(FieldVector3D<T> axis,
             T angle,
             RotationConvention convention)Build a rotation from an axis and an angle. | 
| Line(Vector3D p1,
    Vector3D p2)Deprecated. 
 as of 3.3, replaced with  Line.Line(Vector3D, Vector3D, double) | 
| Line(Vector3D p1,
    Vector3D p2,
    double tolerance)Build a line from two points. | 
| Rotation(Vector3D axis,
        double angle)Deprecated. 
 as of 3.6, replaced with  Rotation.Rotation(Vector3D, double, RotationConvention) | 
| Rotation(Vector3D axis,
        double angle,
        RotationConvention convention)Build a rotation from an axis and an angle. | 
| SubLine(Segment segment)Create a sub-line from a segment. | 
| SubLine(Vector3D start,
       Vector3D end)Deprecated. 
 as of 3.3, replaced with  SubLine.SubLine(Vector3D, Vector3D, double) | 
| SubLine(Vector3D start,
       Vector3D end,
       double tolerance)Create a sub-line from two endpoints. | 
| Modifier and Type | Method and Description | 
|---|---|
| static Transform<Euclidean2D,Euclidean1D> | Line. getTransform(AffineTransform transform)Deprecated. 
 as of 3.6, replaced with  Line.getTransform(double, double, double, double, double, double) | 
| static Transform<Euclidean2D,Euclidean1D> | Line. getTransform(double cXX,
            double cYX,
            double cXY,
            double cYY,
            double cX1,
            double cY1)Get a  Transformembedding an affine transform. | 
| Constructor and Description | 
|---|
| ConvexHull2D(Vector2D[] vertices,
            double tolerance)Simple constructor. | 
| Modifier and Type | Class and Description | 
|---|---|
| static class  | ArcsSet.InconsistentStateAt2PiWrappingSpecialized exception for inconsistent BSP tree state inconsistency. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | IllConditionedOperatorExceptionAn exception to be thrown when the condition number of a
  RealLinearOperatoris too high. | 
| class  | MatrixDimensionMismatchExceptionException to be thrown when either the number of rows or the number of
 columns of a matrix do not match the expected values. | 
| class  | NonPositiveDefiniteMatrixExceptionException to be thrown when a positive definite matrix is expected. | 
| class  | NonPositiveDefiniteOperatorExceptionException to be thrown when a symmetric, definite positive
  RealLinearOperatoris expected. | 
| class  | NonSelfAdjointOperatorExceptionException to be thrown when a self-adjoint  RealLinearOperatoris expected. | 
| class  | NonSquareMatrixExceptionException to be thrown when a square matrix is expected. | 
| class  | NonSquareOperatorExceptionException to be thrown when a square linear operator is expected. | 
| class  | NonSymmetricMatrixExceptionException to be thrown when a symmetric matrix is expected. | 
| class  | SingularMatrixExceptionException to be thrown when a non-singular matrix is expected. | 
| class  | SingularOperatorExceptionException to be thrown when trying to invert a singular operator. | 
| Modifier and Type | Method and Description | 
|---|---|
| List<CentroidCluster<T>> | KMeansPlusPlusClusterer. cluster(Collection<T> points)Runs the K-means++ clustering algorithm. | 
| List<CentroidCluster<T>> | FuzzyKMeansClusterer. cluster(Collection<T> dataPoints)Performs Fuzzy K-Means cluster analysis. | 
| abstract List<? extends Cluster<T>> | Clusterer. cluster(Collection<T> points)Perform a cluster analysis on the given set of  Clusterableinstances. | 
| List<CentroidCluster<T>> | MultiKMeansPlusPlusClusterer. cluster(Collection<T> points)Runs the K-means++ clustering algorithm. | 
| Modifier and Type | Class and Description | 
|---|---|
| static class  | JacobianMatrices.MismatchedEquationsSpecial exception for equations mismatch. | 
| class  | UnknownParameterExceptionException to be thrown when a parameter is unknown. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | ContinuousOutputFieldModel. append(ContinuousOutputFieldModel<T> model)Append another model at the end of the instance. | 
| void | ContinuousOutputModel. append(ContinuousOutputModel model)Append another model at the end of the instance. | 
| T[] | FieldEquationsMapper. extractEquationData(int index,
                   T[] complete)Extract equation data from a complete state or derivative array. | 
| void | SecondOrderIntegrator. integrate(SecondOrderDifferentialEquations equations,
         double t0,
         double[] y0,
         double[] yDot0,
         double t,
         double[] y,
         double[] yDot)Integrate the differential equations up to the given time | 
| Modifier and Type | Method and Description | 
|---|---|
| void | ValueServer. fill(double[] values)Fills the input array with values generated using getNext() repeatedly. | 
| double[] | ValueServer. fill(int length)Returns an array of length  lengthwith values generated
 using getNext() repeatedly. | 
| double | ValueServer. getNext()Returns the next generated value, generated according
 to the mode value (see MODE constants). | 
| int | RandomDataImpl. nextInversionDeviate(IntegerDistribution distribution)Deprecated. 
 use the distribution's sample() method | 
| double | RandomDataImpl. nextInversionDeviate(RealDistribution distribution)Deprecated. 
 use the distribution's sample() method | 
| Modifier and Type | Method and Description | 
|---|---|
| double | BesselJ. value(double x)Returns the value of the constructed Bessel function of the first kind,
 for the passed argument. | 
| static double | BesselJ. value(double order,
     double x)Returns the first Bessel function, \(J_{order}(x)\). | 
| Modifier and Type | Method and Description | 
|---|---|
| void | Frequency. addValue(char v)Adds 1 to the frequency count for v. | 
| void | Frequency. addValue(Comparable<?> v)Adds 1 to the frequency count for v. | 
| void | Frequency. addValue(int v)Adds 1 to the frequency count for v. | 
| void | Frequency. addValue(long v)Adds 1 to the frequency count for v. | 
| static double | StatUtils. geometricMean(double[] values)Returns the geometric mean of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. geometricMean(double[] values,
             int begin,
             int length)Returns the geometric mean of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| void | Frequency. incrementValue(char v,
              long increment)Increments the frequency count for v. | 
| void | Frequency. incrementValue(Comparable<?> v,
              long increment)Increments the frequency count for v. | 
| void | Frequency. incrementValue(int v,
              long increment)Increments the frequency count for v. | 
| void | Frequency. incrementValue(long v,
              long increment)Increments the frequency count for v. | 
| static double | StatUtils. max(double[] values)Returns the maximum of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. max(double[] values,
   int begin,
   int length)Returns the maximum of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. mean(double[] values)Returns the arithmetic mean of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. mean(double[] values,
    int begin,
    int length)Returns the arithmetic mean of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. min(double[] values)Returns the minimum of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. min(double[] values,
   int begin,
   int length)Returns the minimum of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double[] | StatUtils. mode(double[] sample)Returns the sample mode(s). | 
| static double | StatUtils. percentile(double[] values,
          double p)Returns an estimate of the  pth percentile of the values
 in thevaluesarray. | 
| static double | StatUtils. percentile(double[] values,
          int begin,
          int length,
          double p)Returns an estimate of the  pth percentile of the values
 in thevaluesarray, starting with the element in (0-based)
 positionbeginin the array and includinglengthvalues. | 
| static double | StatUtils. populationVariance(double[] values)Returns the 
 population variance of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. populationVariance(double[] values,
                  double mean)Returns the 
 population variance of the entries in the input array, using the
 precomputed mean value. | 
| static double | StatUtils. populationVariance(double[] values,
                  double mean,
                  int begin,
                  int length)Returns the 
 population variance of the entries in the specified portion of
 the input array, using the precomputed mean value. | 
| static double | StatUtils. populationVariance(double[] values,
                  int begin,
                  int length)Returns the 
 population variance of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. product(double[] values)Returns the product of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. product(double[] values,
       int begin,
       int length)Returns the product of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. sum(double[] values)Returns the sum of the values in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. sum(double[] values,
   int begin,
   int length)Returns the sum of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. sumLog(double[] values)Returns the sum of the natural logs of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. sumLog(double[] values,
      int begin,
      int length)Returns the sum of the natural logs of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. sumSq(double[] values)Returns the sum of the squares of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. sumSq(double[] values,
     int begin,
     int length)Returns the sum of the squares of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| static double | StatUtils. variance(double[] values)Returns the variance of the entries in the input array, or
  Double.NaNif the array is empty. | 
| static double | StatUtils. variance(double[] values,
        double mean)Returns the variance of the entries in the input array, using the
 precomputed mean value. | 
| static double | StatUtils. variance(double[] values,
        double mean,
        int begin,
        int length)Returns the variance of the entries in the specified portion of
 the input array, using the precomputed mean value. | 
| static double | StatUtils. variance(double[] values,
        int begin,
        int length)Returns the variance of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| Modifier and Type | Method and Description | 
|---|---|
| List<Cluster<T>> | KMeansPlusPlusClusterer. cluster(Collection<T> points,
       int k,
       int maxIterations)Deprecated.  Runs the K-means++ clustering algorithm. | 
| List<Cluster<T>> | KMeansPlusPlusClusterer. cluster(Collection<T> points,
       int k,
       int numTrials,
       int maxIterationsPerTrial)Deprecated.  Runs the K-means++ clustering algorithm. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected RealMatrix | Covariance. computeCovarianceMatrix(double[][] data)Create a covariance matrix from a rectangular array whose columns represent
 covariates. | 
| protected RealMatrix | Covariance. computeCovarianceMatrix(double[][] data,
                       boolean biasCorrected)Compute a covariance matrix from a rectangular array whose columns represent
 covariates. | 
| protected RealMatrix | Covariance. computeCovarianceMatrix(RealMatrix matrix)Create a covariance matrix from a matrix whose columns represent
 covariates. | 
| protected RealMatrix | Covariance. computeCovarianceMatrix(RealMatrix matrix,
                       boolean biasCorrected)Compute a covariance matrix from a matrix whose columns represent
 covariates. | 
| double | Covariance. covariance(double[] xArray,
          double[] yArray)Computes the covariance between the two arrays, using the bias-corrected
 formula. | 
| double | Covariance. covariance(double[] xArray,
          double[] yArray,
          boolean biasCorrected)Computes the covariance between the two arrays. | 
| Constructor and Description | 
|---|
| Covariance(double[][] data)Create a Covariance matrix from a rectangular array
 whose columns represent covariates. | 
| Covariance(double[][] data,
          boolean biasCorrected)Create a Covariance matrix from a rectangular array
 whose columns represent covariates. | 
| Covariance(RealMatrix matrix)Create a covariance matrix from a matrix whose columns
 represent covariates. | 
| Covariance(RealMatrix matrix,
          boolean biasCorrected)Create a covariance matrix from a matrix whose columns
 represent covariates. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | AbstractUnivariateStatistic. evaluate()Returns the result of evaluating the statistic over the stored data. | 
| double | AbstractUnivariateStatistic. evaluate(double[] values)Returns the result of evaluating the statistic over the input array. | 
| double | UnivariateStatistic. evaluate(double[] values)Returns the result of evaluating the statistic over the input array. | 
| double | AbstractStorelessUnivariateStatistic. evaluate(double[] values)This default implementation calls  AbstractStorelessUnivariateStatistic.clear(), then invokesAbstractStorelessUnivariateStatistic.increment(double)in a loop over the the input array, and then usesAbstractStorelessUnivariateStatistic.getResult()to compute the return value. | 
| double | WeightedEvaluation. evaluate(double[] values,
        double[] weights)Returns the result of evaluating the statistic over the input array,
 using the supplied weights. | 
| double | WeightedEvaluation. evaluate(double[] values,
        double[] weights,
        int begin,
        int length)Returns the result of evaluating the statistic over the specified entries
 in the input array, using corresponding entries in the supplied weights array. | 
| abstract double | AbstractUnivariateStatistic. evaluate(double[] values,
        int begin,
        int length)Returns the result of evaluating the statistic over the specified entries
 in the input array. | 
| double | UnivariateStatistic. evaluate(double[] values,
        int begin,
        int length)Returns the result of evaluating the statistic over the specified entries
 in the input array. | 
| double | AbstractStorelessUnivariateStatistic. evaluate(double[] values,
        int begin,
        int length)This default implementation calls  AbstractStorelessUnivariateStatistic.clear(), then invokesAbstractStorelessUnivariateStatistic.increment(double)in a loop over the specified portion of the input
 array, and then usesAbstractStorelessUnivariateStatistic.getResult()to compute the return value. | 
| double | DescriptiveStatistics. getPercentile(double p)Returns an estimate for the pth percentile of the stored values. | 
| void | AbstractStorelessUnivariateStatistic. incrementAll(double[] values)This default implementation just calls  AbstractStorelessUnivariateStatistic.increment(double)in a loop over
 the input array. | 
| void | StorelessUnivariateStatistic. incrementAll(double[] values)Updates the internal state of the statistic to reflect addition of
 all values in the values array. | 
| void | AbstractStorelessUnivariateStatistic. incrementAll(double[] values,
            int begin,
            int length)This default implementation just calls  AbstractStorelessUnivariateStatistic.increment(double)in a loop over
 the specified portion of the input array. | 
| void | StorelessUnivariateStatistic. incrementAll(double[] values,
            int start,
            int length)Updates the internal state of the statistic to reflect addition of
 the values in the designated portion of the values array. | 
| void | AbstractUnivariateStatistic. setData(double[] values,
       int begin,
       int length)Set the data array. | 
| void | DescriptiveStatistics. setPercentileImpl(UnivariateStatistic percentileImpl)Sets the implementation to be used by  DescriptiveStatistics.getPercentile(double). | 
| void | DescriptiveStatistics. setWindowSize(int windowSize)WindowSize controls the number of values that contribute to the
 reported statistics. | 
| void | SynchronizedDescriptiveStatistics. setWindowSize(int windowSize)WindowSize controls the number of values that contribute to the
 reported statistics. | 
| protected boolean | AbstractUnivariateStatistic. test(double[] values,
    double[] weights,
    int begin,
    int length)This method is used by  evaluate(double[], double[], int, int)methods
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero. | 
| protected boolean | AbstractUnivariateStatistic. test(double[] values,
    double[] weights,
    int begin,
    int length,
    boolean allowEmpty)This method is used by  evaluate(double[], double[], int, int)methods
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero. | 
| protected boolean | AbstractUnivariateStatistic. test(double[] values,
    int begin,
    int length)This method is used by  evaluate(double[], int, int)methods
 to verify that the input parameters designate a subarray of positive length. | 
| protected boolean | AbstractUnivariateStatistic. test(double[] values,
    int begin,
    int length,
    boolean allowEmpty)This method is used by  evaluate(double[], int, int)methods
 to verify that the input parameters designate a subarray of positive length. | 
| Constructor and Description | 
|---|
| DescriptiveStatistics(int window)Construct a DescriptiveStatistics instance with the specified window | 
| SynchronizedDescriptiveStatistics(int window)Construct an instance with finite window | 
| Modifier and Type | Method and Description | 
|---|---|
| double | Variance. evaluate(double[] values)Returns the variance of the entries in the input array, or
  Double.NaNif the array is empty. | 
| double | StandardDeviation. evaluate(double[] values)Returns the Standard Deviation of the entries in the input array, or
  Double.NaNif the array is empty. | 
| double | SemiVariance. evaluate(double[] values,
        double cutoff)Returns the  SemiVarianceof the designated values against the cutoff, using
 instance properties variancDirection and biasCorrection. | 
| double | Variance. evaluate(double[] values,
        double mean)Returns the variance of the entries in the input array, using the
 precomputed mean value. | 
| double | StandardDeviation. evaluate(double[] values,
        double mean)Returns the Standard Deviation of the entries in the input array, using
 the precomputed mean value. | 
| double | Mean. evaluate(double[] values,
        double[] weights)Returns the weighted arithmetic mean of the entries in the input array. | 
| double | Variance. evaluate(double[] values,
        double[] weights)
 Returns the weighted variance of the entries in the the input array. | 
| double | Variance. evaluate(double[] values,
        double[] weights,
        double mean)Returns the weighted variance of the values in the input array, using
 the precomputed weighted mean value. | 
| double | Variance. evaluate(double[] values,
        double[] weights,
        double mean,
        int begin,
        int length)Returns the weighted variance of the entries in the specified portion of
 the input array, using the precomputed weighted mean value. | 
| double | Mean. evaluate(double[] values,
        double[] weights,
        int begin,
        int length)Returns the weighted arithmetic mean of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Variance. evaluate(double[] values,
        double[] weights,
        int begin,
        int length)Returns the weighted variance of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Variance. evaluate(double[] values,
        double mean,
        int begin,
        int length)Returns the variance of the entries in the specified portion of
 the input array, using the precomputed mean value. | 
| double | StandardDeviation. evaluate(double[] values,
        double mean,
        int begin,
        int length)Returns the Standard Deviation of the entries in the specified portion of
 the input array, using the precomputed mean value. | 
| double | SemiVariance. evaluate(double[] values,
        double cutoff,
        SemiVariance.Direction direction)Returns the  SemiVarianceof the designated values against the cutoff in the
 given direction, using the current value of the biasCorrection instance property. | 
| double | SemiVariance. evaluate(double[] values,
        double cutoff,
        SemiVariance.Direction direction,
        boolean corrected,
        int start,
        int length)Returns the  SemiVarianceof the designated values against the cutoff
 in the given direction with the provided bias correction. | 
| double | SemiVariance. evaluate(double[] values,
        int start,
        int length)Returns the  SemiVarianceof the designated values against the mean, using
 instance properties varianceDirection and biasCorrection. | 
| double | Mean. evaluate(double[] values,
        int begin,
        int length)Returns the arithmetic mean of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Kurtosis. evaluate(double[] values,
        int begin,
        int length)Returns the kurtosis of the entries in the specified portion of the
 input array. | 
| double | GeometricMean. evaluate(double[] values,
        int begin,
        int length)Returns the geometric mean of the entries in the specified portion
 of the input array. | 
| double | Variance. evaluate(double[] values,
        int begin,
        int length)Returns the variance of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Skewness. evaluate(double[] values,
        int begin,
        int length)Returns the Skewness of the entries in the specifed portion of the
 input array. | 
| double | StandardDeviation. evaluate(double[] values,
        int begin,
        int length)Returns the Standard Deviation of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | SemiVariance. evaluate(double[] values,
        SemiVariance.Direction direction)This method calculates  SemiVariancefor the entire array against the mean, using
 the current value of the biasCorrection instance property. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | Percentile. evaluate(double p)Returns the result of evaluating the statistic over the stored data. | 
| double | Percentile. evaluate(double[] values,
        double p)Returns an estimate of the  pth percentile of the values
 in thevaluesarray. | 
| double | Max. evaluate(double[] values,
        int begin,
        int length)Returns the maximum of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Min. evaluate(double[] values,
        int begin,
        int length)Returns the minimum of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Percentile. evaluate(double[] values,
        int start,
        int length)Returns an estimate of the  quantileth percentile of the
 designated values in thevaluesarray. | 
| double | Percentile. evaluate(double[] values,
        int begin,
        int length,
        double p)Returns an estimate of the  pth percentile of the values
 in thevaluesarray, starting with the element in (0-based)
 positionbeginin the array and includinglengthvalues. | 
| void | Percentile. setData(double[] values,
       int begin,
       int length)Set the data array. | 
| void | Percentile. setQuantile(double p)Sets the value of the quantile field (determines what percentile is
 computed when evaluate() is called with no quantile argument). | 
| Constructor and Description | 
|---|
| Percentile(double quantile)Constructs a Percentile with the specific quantile value and the following
 
   default method type:  Percentile.EstimationType.LEGACYdefault NaN strategy:NaNStrategy.REMOVEDa Kth Selector :KthSelector | 
| Percentile(double quantile,
          Percentile.EstimationType estimationType,
          NaNStrategy nanStrategy,
          KthSelector kthSelector)Constructs a Percentile with the specific quantile value,
  Percentile.EstimationType,NaNStrategyandKthSelector. | 
| Modifier and Type | Method and Description | 
|---|---|
| double | Sum. evaluate(double[] values,
        double[] weights)The weighted sum of the entries in the the input array. | 
| double | Product. evaluate(double[] values,
        double[] weights)Returns the weighted product of the entries in the input array. | 
| double | Sum. evaluate(double[] values,
        double[] weights,
        int begin,
        int length)The weighted sum of the entries in the specified portion of
 the input array, or 0 if the designated subarray
 is empty. | 
| double | Product. evaluate(double[] values,
        double[] weights,
        int begin,
        int length)Returns the weighted product of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | SumOfLogs. evaluate(double[] values,
        int begin,
        int length)Returns the sum of the natural logs of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | Sum. evaluate(double[] values,
        int begin,
        int length)The sum of the entries in the specified portion of
 the input array, or 0 if the designated subarray
 is empty. | 
| double | Product. evaluate(double[] values,
        int begin,
        int length)Returns the product of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| double | SumOfSquares. evaluate(double[] values,
        int begin,
        int length)Returns the sum of the squares of the entries in the specified portion of
 the input array, or  Double.NaNif the designated subarray
 is empty. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected double | TTest. tTest(double m,
     double mu,
     double v,
     double n)Computes p-value for 2-sided, 1-sample t-test. | 
| Modifier and Type | Class and Description | 
|---|---|
| class  | ModelSpecificationExceptionException thrown when a regression model is not correctly specified. | 
| Modifier and Type | Method and Description | 
|---|---|
| void | OLSMultipleLinearRegression. newSampleData(double[] y,
             double[][] x)Loads model x and y sample data, overriding any previous sample. | 
| RegressionResults | SimpleRegression. regress(int[] variablesToInclude)Performs a regression on data present in buffers including only regressors
 indexed in variablesToInclude and outputs a RegressionResults object | 
| RegressionResults | UpdatingMultipleLinearRegression. regress(int[] variablesToInclude)Performs a regression on data present in buffers including only regressors
 indexed in variablesToInclude and outputs a RegressionResults object | 
| protected void | AbstractMultipleLinearRegression. validateSampleData(double[][] x,
                  double[] y)Validates sample data. | 
| Modifier and Type | Method and Description | 
|---|---|
| static int | TransformUtils. exactLog2(int n)Returns the base-2 logarithm of the specified  int. | 
| protected double[] | FastCosineTransformer. fct(double[] f)Perform the FCT algorithm (including inverse). | 
| protected double[] | FastHadamardTransformer. fht(double[] x)The FHT (Fast Hadamard Transformation) which uses only subtraction and
 addition. | 
| protected int[] | FastHadamardTransformer. fht(int[] x)Returns the forward transform of the specified integer data set. | 
| protected double[] | FastSineTransformer. fst(double[] f)Perform the FST algorithm (including inverse). | 
| double[] | RealTransformer. transform(double[] f,
         TransformType type)Returns the (forward, inverse) transform of the specified real data set. | 
| double[] | FastCosineTransformer. transform(double[] f,
         TransformType type)Returns the (forward, inverse) transform of the specified real data set. | 
| double[] | RealTransformer. transform(UnivariateFunction f,
         double min,
         double max,
         int n,
         TransformType type)Returns the (forward, inverse) transform of the specified real function,
 sampled on the specified interval. | 
| double[] | FastCosineTransformer. transform(UnivariateFunction f,
         double min,
         double max,
         int n,
         TransformType type)Returns the (forward, inverse) transform of the specified real function,
 sampled on the specified interval. | 
| Modifier and Type | Method and Description | 
|---|---|
| protected void | ResizableDoubleArray. checkContractExpand(float contraction,
                   float expansion)Deprecated. 
 As of 3.1. Please use
  ResizableDoubleArray.checkContractExpand(double,double)instead. | 
| void | ResizableDoubleArray. discardFrontElements(int i)Discards the  iinitial elements of the array. | 
| void | ResizableDoubleArray. discardMostRecentElements(int i)Discards the  ilast elements of the array. | 
| static double[] | MathArrays. normalizeArray(double[] values,
              double normalizedSum)Normalizes an array to make it sum to a specified value. | 
| int | CentralPivotingStrategy. pivotIndex(double[] work,
          int begin,
          int end)Find pivot index of the array so that partition and Kth
 element selection can be made | 
| int | RandomPivotingStrategy. pivotIndex(double[] work,
          int begin,
          int end)Find pivot index of the array so that partition and Kth
 element selection can be made | 
| int | MedianOf3PivotingStrategy. pivotIndex(double[] work,
          int begin,
          int end)Find pivot index of the array so that partition and Kth
 element selection can be made | 
| int | PivotingStrategyInterface. pivotIndex(double[] work,
          int begin,
          int end)Find pivot index of the array so that partition and Kth
 element selection can be made | 
| static float | Precision. round(float x,
     int scale,
     int roundingMethod)Rounds the given value to the specified number of decimal places. | 
| void | ResizableDoubleArray. setContractionCriteria(float contractionCriteria)Deprecated. 
 As of 3.1 (to be removed in 4.0 as field will become "final"). | 
| void | ResizableDoubleArray. setExpansionFactor(float expansionFactor)Deprecated. 
 As of 3.1 (to be removed in 4.0 as field will become "final"). | 
| void | ResizableDoubleArray. setExpansionMode(int expansionMode)Deprecated. 
 As of 3.1. Please use  ResizableDoubleArray.setExpansionMode(ExpansionMode)instead. | 
| protected void | ResizableDoubleArray. setInitialCapacity(int initialCapacity)Deprecated. 
 As of 3.1, this is a no-op. | 
| void | ResizableDoubleArray. setNumElements(int i)This function allows you to control the number of elements contained
 in this array, and can be used to "throw out" the last n values in an
 array. | 
| double | DefaultTransformer. transform(Object o) | 
| double | NumberTransformer. transform(Object o)Implementing this interface provides a facility to transform
 from Object to Double. | 
| double | TransformerMap. transform(Object o)Attempts to transform the Object against the map of
 NumberTransformers. | 
| static boolean | MathArrays. verifyValues(double[] values,
            double[] weights,
            int begin,
            int length)This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero. | 
| static boolean | MathArrays. verifyValues(double[] values,
            double[] weights,
            int begin,
            int length,
            boolean allowEmpty)This method is used
 to verify that the begin and length parameters designate a subarray of positive length
 and the weights are all non-negative, non-NaN, finite, and not all zero. | 
| static boolean | MathArrays. verifyValues(double[] values,
            int begin,
            int length)This method is used
 to verify that the input parameters designate a subarray of positive length. | 
| static boolean | MathArrays. verifyValues(double[] values,
            int begin,
            int length,
            boolean allowEmpty)This method is used
 to verify that the input parameters designate a subarray of positive length. | 
| Constructor and Description | 
|---|
| ResizableDoubleArray(int initialCapacity)Creates an instance with the specified initial capacity. | 
| ResizableDoubleArray(int initialCapacity,
                    double expansionFactor)Creates an instance with the specified initial capacity
 and expansion factor. | 
| ResizableDoubleArray(int initialCapacity,
                    double expansionFactor,
                    double contractionCriterion)Creates an instance with the specified initial capacity,
 expansion factor, and contraction criteria. | 
| ResizableDoubleArray(int initialCapacity,
                    double expansionFactor,
                    double contractionCriterion,
                    ResizableDoubleArray.ExpansionMode expansionMode,
                    double... data)Creates an instance with the specified properties. | 
| ResizableDoubleArray(int initialCapacity,
                    float expansionFactor)Deprecated. 
 As of 3.1. Please use
  ResizableDoubleArray.ResizableDoubleArray(int,double)instead. | 
| ResizableDoubleArray(int initialCapacity,
                    float expansionFactor,
                    float contractionCriteria)Deprecated. 
 As of 3.1. Please use
  ResizableDoubleArray.ResizableDoubleArray(int,double,double)instead. | 
| ResizableDoubleArray(int initialCapacity,
                    float expansionFactor,
                    float contractionCriteria,
                    int expansionMode)Deprecated. 
 As of 3.1. Please use
  ResizableDoubleArray.ResizableDoubleArray(int,double,double,ExpansionMode,double[])instead. | 
Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.