Uses of Class org.apache.commons.math3.exception.MathIllegalArgumentException (Apache Commons Math 3.3 API)

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

- Packages that use MathIllegalArgumentException
  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.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.

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

    Methods in org.apache.commons.math3.analysis.differentiation that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `DerivativeStructure[]` | UnivariateDifferentiableVectorFunction.`value(DerivativeStructure x)` Compute the value for the function.
    `DerivativeStructure[][]` | UnivariateDifferentiableMatrixFunction.`value(DerivativeStructure x)` Compute the value for the function.
    `DerivativeStructure` | MultivariateDifferentiableFunction.`value(DerivativeStructure[] point)` Compute the value for the function at the given point.
    `DerivativeStructure[]` | MultivariateDifferentiableVectorFunction.`value(DerivativeStructure[] point)` Compute the value for the function at the given point.

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

    Methods in org.apache.commons.math3.analysis.integration that throw MathIllegalArgumentException
    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.

    Constructors in org.apache.commons.math3.analysis.integration that throw MathIllegalArgumentException
    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.

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

    Methods in org.apache.commons.math3.analysis.interpolation that throw MathIllegalArgumentException
    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.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.analysis.solvers

    Methods in org.apache.commons.math3.analysis.solvers that throw MathIllegalArgumentException
    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`.

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

    Methods in org.apache.commons.math3.complex that throw MathIllegalArgumentException
    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`-th `n`-th root of unity.
    `static Complex` | ComplexUtils.`polar2Complex(double r, double theta)` Creates a complex number from the given polar representation.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.exception

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.exception
    Modifier and Type | Class and Description
    --- | ---
    `class` | `DimensionMismatchException` Exception to be thrown when two dimensions differ.
    `class` | `InsufficientDataException` Exception to be thrown when there is insufficient data to perform a computation.
    `class` | `MathIllegalNumberException` Base class for exceptions raised by a wrong number.
    `class` | `MultiDimensionMismatchException` Exception to be thrown when two sets of dimensions differ.
    `class` | `NoBracketingException` Exception to be thrown when function values have the same sign at both ends of an interval.
    `class` | `NoDataException` Exception to be thrown when the required data is missing.
    `class` | `NonMonotonicSequenceException` Exception to be thrown when the a sequence of values is not monotonically increasing or decreasing.
    `class` | `NotANumberException` Exception to be thrown when a number is not a number.
    `class` | `NotFiniteNumberException` Exception to be thrown when a number is not finite.
    `class` | `NotPositiveException` Exception to be thrown when the argument is negative.
    `class` | `NotStrictlyPositiveException` Exception to be thrown when the argument is not greater than 0.
    `class` | `NullArgumentException` All conditions checks that fail due to a `null` argument must throw this exception.
    `class` | `NumberIsTooLargeException` Exception to be thrown when a number is too large.
    `class` | `NumberIsTooSmallException` Exception to be thrown when a number is too small.
    `class` | `OutOfRangeException` Exception to be thrown when some argument is out of range.
    `class` | `ZeroException` Exception to be thrown when zero is provided where it is not allowed.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.fraction

    Methods in org.apache.commons.math3.fraction that throw MathIllegalArgumentException
    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.

    Constructors in org.apache.commons.math3.fraction that throw MathIllegalArgumentException
    Constructor and Description
    `BigFraction(double value)` Create a fraction given the double value.

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

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.genetics
    Modifier and Type | Class and Description
    --- | ---
    `class` | `InvalidRepresentationException` Exception indicating that the representation of a chromosome is not valid.

    Methods in org.apache.commons.math3.genetics that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `ChromosomePair` | NPointCrossover.`crossover(Chromosome first, Chromosome second)` Performs a N-point crossover.
    `ChromosomePair` | OrderedCrossover.`crossover(Chromosome first, Chromosome second)` Perform a crossover operation on the given chromosomes.
    `ChromosomePair` | OnePointCrossover.`crossover(Chromosome first, Chromosome second)` Performs one point crossover.
    `ChromosomePair` | CrossoverPolicy.`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.
    `ChromosomePair` | CycleCrossover.`crossover(Chromosome first, Chromosome second)` Perform a crossover operation on the given chromosomes.
    `static <S> List<Double>` | RandomKey.`inducedPermutation(List<S> originalData, List<S> permutedData)` Generates a representation of a permutation corresponding to a permutation which yields `permutedData` when applied to `originalData`.
    `Chromosome` | MutationPolicy.`mutate(Chromosome original)` Mutate the given chromosome.
    `Chromosome` | BinaryMutation.`mutate(Chromosome original)` Mutate the given chromosome.
    `Chromosome` | RandomKeyMutation.`mutate(Chromosome original)` Mutate the given chromosome.
    `ChromosomePair` | TournamentSelection.`select(Population population)` Select two chromosomes from the population.
    `ChromosomePair` | SelectionPolicy.`select(Population population)` Select two chromosomes from the population.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.geometry.euclidean.threed

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.geometry.euclidean.threed
    Modifier and Type | Class and Description
    --- | ---
    `class` | `NotARotationMatrixException` This class represents exceptions thrown while building rotations from matrices.

    Methods in org.apache.commons.math3.geometry.euclidean.threed that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `void` | Line.`reset(Vector3D p1, Vector3D p2)` Reset the instance as if built from two points.

    Constructors in org.apache.commons.math3.geometry.euclidean.threed that throw MathIllegalArgumentException
    Constructor and Description
    `FieldRotation(FieldVector3D<T> axis, T angle)` 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)` 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.

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

    Methods in org.apache.commons.math3.geometry.euclidean.twod that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `static Transform<Euclidean2D,Euclidean1D>` | Line.`getTransform(AffineTransform transform)` Get a `Transform` embedding an affine transform.

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

    Constructors in org.apache.commons.math3.geometry.euclidean.twod.hull that throw MathIllegalArgumentException
    Constructor and Description
    `ConvexHull2D(Vector2D[] vertices, double tolerance)` Simple constructor.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.geometry.spherical.oned

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.geometry.spherical.oned
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ArcsSet.InconsistentStateAt2PiWrapping` Specialized exception for inconsistent BSP tree state inconsistency.

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

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.linear
    Modifier and Type | Class and Description
    --- | ---
    `class` | `IllConditionedOperatorException` An exception to be thrown when the condition number of a `RealLinearOperator` is too high.
    `class` | `MatrixDimensionMismatchException` Exception to be thrown when either the number of rows or the number of columns of a matrix do not match the expected values.
    `class` | `NonPositiveDefiniteMatrixException` Exception to be thrown when a positive definite matrix is expected.
    `class` | `NonPositiveDefiniteOperatorException` Exception to be thrown when a symmetric, definite positive `RealLinearOperator` is expected.
    `class` | `NonSelfAdjointOperatorException` Exception to be thrown when a self-adjoint `RealLinearOperator` is expected.
    `class` | `NonSquareMatrixException` Exception to be thrown when a square matrix is expected.
    `class` | `NonSquareOperatorException` Exception to be thrown when a square linear operator is expected.
    `class` | `NonSymmetricMatrixException` Exception to be thrown when a symmetric matrix is expected.
    `class` | `SingularMatrixException` Exception to be thrown when a non-singular matrix is expected.
    `class` | `SingularOperatorException` Exception to be thrown when trying to invert a singular operator.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.ml.clustering

    Methods in org.apache.commons.math3.ml.clustering that throw MathIllegalArgumentException
    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 `Clusterable` instances.
    `List<CentroidCluster<T>>` | MultiKMeansPlusPlusClusterer.`cluster(Collection<T> points)` Runs the K-means++ clustering algorithm.

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

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.ode
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `JacobianMatrices.MismatchedEquations` Special exception for equations mismatch.
    `class` | `UnknownParameterException` Exception to be thrown when a parameter is unknown.

    Methods in org.apache.commons.math3.ode that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `void` | ContinuousOutputModel.`append(ContinuousOutputModel model)` Append another model at the end of the instance.
    `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

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

    Methods in org.apache.commons.math3.random that throw MathIllegalArgumentException
    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 `length` with 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

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

    Methods in org.apache.commons.math3.stat that throw MathIllegalArgumentException
    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.NaN` if 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.NaN` if 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.NaN` if 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.NaN` if the designated subarray is empty.
    `static double` | StatUtils.`mean(double[] values)` Returns the arithmetic mean of the entries in the input array, or `Double.NaN` if 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.NaN` if the designated subarray is empty.
    `static double` | StatUtils.`min(double[] values)` Returns the minimum of the entries in the input array, or `Double.NaN` if 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.NaN` if 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 `p`th percentile of the values in the `values` array.
    `static double` | StatUtils.`percentile(double[] values, int begin, int length, double p)` Returns an estimate of the `p`th percentile of the values in the `values` array, starting with the element in (0-based) position `begin` in the array and including `length` values.
    `static double` | StatUtils.`populationVariance(double[] values)` Returns the population variance of the entries in the input array, or `Double.NaN` if 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.NaN` if the designated subarray is empty.
    `static double` | StatUtils.`product(double[] values)` Returns the product of the entries in the input array, or `Double.NaN` if 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.NaN` if the designated subarray is empty.
    `static double` | StatUtils.`sum(double[] values)` Returns the sum of the values in the input array, or `Double.NaN` if 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.NaN` if 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.NaN` if 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.NaN` if 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.NaN` if 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.NaN` if the designated subarray is empty.
    `static double` | StatUtils.`variance(double[] values)` Returns the variance of the entries in the input array, or `Double.NaN` if 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.NaN` if the designated subarray is empty.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.stat.clustering

    Methods in org.apache.commons.math3.stat.clustering that throw MathIllegalArgumentException
    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.

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

    Methods in org.apache.commons.math3.stat.correlation that throw MathIllegalArgumentException
    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.

    Constructors in org.apache.commons.math3.stat.correlation that throw MathIllegalArgumentException
    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.

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

    Methods in org.apache.commons.math3.stat.descriptive that throw MathIllegalArgumentException
    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 invokes `AbstractStorelessUnivariateStatistic.increment(double)` in a loop over the the input array, and then uses `AbstractStorelessUnivariateStatistic.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 invokes `AbstractStorelessUnivariateStatistic.increment(double)` in a loop over the specified portion of the input array, and then uses `AbstractStorelessUnivariateStatistic.getResult()` to compute the return value.
    `double` | DescriptiveStatistics.`getPercentile(double p)` Returns an estimate for the pth percentile of the stored values.
    `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)` This default implementation just calls `AbstractStorelessUnivariateStatistic.increment(double)` in a loop over 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` | 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` | 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` | SynchronizedDescriptiveStatistics.`setWindowSize(int windowSize)` WindowSize controls the number of values that contribute to the reported statistics.
    `void` | DescriptiveStatistics.`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.

    Constructors in org.apache.commons.math3.stat.descriptive that throw MathIllegalArgumentException
    Constructor and Description
    `DescriptiveStatistics(int window)` Construct a DescriptiveStatistics instance with the specified window
    `SynchronizedDescriptiveStatistics(int window)` Construct an instance with finite window

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

    Methods in org.apache.commons.math3.stat.descriptive.moment that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `double` | Variance.`evaluate(double[] values)` Returns the variance of the entries in the input array, or `Double.NaN` if the array is empty.
    `double` | StandardDeviation.`evaluate(double[] values)` Returns the Standard Deviation of the entries in the input array, or `Double.NaN` if the array is empty.
    `double` | Variance.`evaluate(double[] values, double mean)` Returns the variance of the entries in the input array, using the precomputed mean value.
    `double` | SemiVariance.`evaluate(double[] values, double cutoff)` Returns the `SemiVariance` of the designated values against the cutoff, using instance properties variancDirection and biasCorrection.
    `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.NaN` if 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.NaN` if 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 `SemiVariance` of 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 `SemiVariance` of the designated values against the cutoff in the given direction with the provided bias correction.
    `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` | Skewness.`evaluate(double[] values, int begin, int length)` Returns the Skewness of the entries in the specifed portion of the input array.
    `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.NaN` if the designated subarray is empty.
    `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.NaN` if the designated subarray is empty.
    `double` | SemiVariance.`evaluate(double[] values, int start, int length)` Returns the `SemiVariance` of the designated values against the mean, using instance properties varianceDirection and biasCorrection.
    `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.NaN` if the designated subarray is empty.
    `double` | SemiVariance.`evaluate(double[] values, SemiVariance.Direction direction)` This method calculates `SemiVariance` for the entire array against the mean, using the current value of the biasCorrection instance property.

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

    Methods in org.apache.commons.math3.stat.descriptive.rank that throw MathIllegalArgumentException
    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 `p`th percentile of the values in the `values` array.
    `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.NaN` if the designated subarray is empty.
    `double` | Percentile.`evaluate(double[] values, int start, int length)` Returns an estimate of the `quantile`th percentile of the designated values in the `values` array.
    `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.NaN` if the designated subarray is empty.
    `double` | Percentile.`evaluate(double[] values, int begin, int length, double p)` Returns an estimate of the `p`th percentile of the values in the `values` array, starting with the element in (0-based) position `begin` in the array and including `length` values.
    `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).

    Constructors in org.apache.commons.math3.stat.descriptive.rank that throw MathIllegalArgumentException
    Constructor and Description
    `Percentile(double p)` Constructs a Percentile with the specific quantile value.

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

    Methods in org.apache.commons.math3.stat.descriptive.summary that throw MathIllegalArgumentException
    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.NaN` if 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.NaN` if 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.NaN` if 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.NaN` if the designated subarray is empty.

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

    Methods in org.apache.commons.math3.stat.inference that throw MathIllegalArgumentException
    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.

  - ### Uses of MathIllegalArgumentException in org.apache.commons.math3.stat.regression

    Subclasses of MathIllegalArgumentException in org.apache.commons.math3.stat.regression
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ModelSpecificationException` Exception thrown when a regression model is not correctly specified.

    Methods in org.apache.commons.math3.stat.regression that throw MathIllegalArgumentException
    Modifier and Type | Method and Description
    --- | ---
    `double` | OLSMultipleLinearRegression.`calculateAdjustedRSquared()` Returns the adjusted R-squared statistic, defined by the formula
    `double` | OLSMultipleLinearRegression.`calculateRSquared()` Returns the R-Squared statistic, defined by the formula
    `double` | OLSMultipleLinearRegression.`calculateTotalSumOfSquares()` Returns the sum of squared deviations of Y from its mean.
    `void` | OLSMultipleLinearRegression.`newSampleData(double[] y, double[][] x)` Loads model x and y sample data, overriding any previous sample.
    `RegressionResults` | UpdatingMultipleLinearRegression.`regress(int[] variablesToInclude)` Performs a regression on data present in buffers including only regressors indexed in variablesToInclude and outputs a RegressionResults object
    `RegressionResults` | SimpleRegression.`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.

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

    Methods in org.apache.commons.math3.transform that throw MathIllegalArgumentException
    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[]` | FastCosineTransformer.`transform(double[] f, TransformType type)` Returns the (forward, inverse) transform of the specified real data set.
    `double[]` | RealTransformer.`transform(double[] f, TransformType type)` Returns the (forward, inverse) transform of the specified real data set.
    `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.
    `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.

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

    Methods in org.apache.commons.math3.util that throw MathIllegalArgumentException
    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 `i` initial elements of the array.
    `void` | ResizableDoubleArray.`discardMostRecentElements(int i)` Discards the `i` last elements of the array.
    `static double[]` | MathArrays.`normalizeArray(double[] values, double normalizedSum)` Normalizes an array to make it sum to a specified value.
    `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` | TransformerMap.`transform(Object o)` Attempts to transform the Object against the map of NumberTransformers.
    `double` | DefaultTransformer.`transform(Object o)`
    `double` | NumberTransformer.`transform(Object o)` Implementing this interface provides a facility to transform from Object to Double.
    `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.

    Constructors in org.apache.commons.math3.util that throw MathIllegalArgumentException
    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–2014 The Apache Software Foundation. All rights reserved.