|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use MathIllegalArgumentException | |
---|---|
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.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 and confidence interval construction. |
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 | |
---|---|
DerivativeStructure[] |
UnivariateDifferentiableVectorFunction.value(DerivativeStructure x)
Compute the value for the function. |
DerivativeStructure[][] |
UnivariateDifferentiableMatrixFunction.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. |
Uses of MathIllegalArgumentException in org.apache.commons.math3.analysis.integration |
---|
Methods in org.apache.commons.math3.analysis.integration that throw MathIllegalArgumentException | |
---|---|
protected double |
LegendreGaussIntegrator.doIntegrate()
Deprecated. Method for implementing actual integration algorithms in derived classes. |
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. |
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
class |
DimensionMismatchException
Exception to be thrown when two dimensions differ. |
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 negative. |
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
class |
InvalidRepresentationException
Exception indicating that the representation of a chromosome is not valid. |
Methods in org.apache.commons.math3.genetics that throw MathIllegalArgumentException | ||
---|---|---|
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 |
UniformCrossover.crossover(Chromosome first,
Chromosome second)
Perform a crossover operation on the given chromosomes. |
|
ChromosomePair |
OrderedCrossover.crossover(Chromosome first,
Chromosome second)
Perform a crossover operation on the given chromosomes. |
|
ChromosomePair |
OnePointCrossover.crossover(Chromosome first,
Chromosome second)
Performs one point crossover. |
|
static
|
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 |
BinaryMutation.mutate(Chromosome original)
Mutate the given chromosome. |
|
Chromosome |
RandomKeyMutation.mutate(Chromosome original)
Mutate the given chromosome. |
|
Chromosome |
MutationPolicy.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. |
Uses of MathIllegalArgumentException in org.apache.commons.math3.geometry.euclidean.threed |
---|
Subclasses of MathIllegalArgumentException in org.apache.commons.math3.geometry.euclidean.threed | |
---|---|
class |
NotARotationMatrixException
This class represents exceptions thrown while building rotations from matrices. |
Methods in org.apache.commons.math3.geometry.euclidean.threed that throw MathIllegalArgumentException | |
---|---|
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 | |
---|---|
FieldRotation(FieldVector3D<T> axis,
T angle)
Build a rotation from an axis and an angle. |
|
Line(Vector3D p1,
Vector3D p2)
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)
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 | |
---|---|
static Transform<Euclidean2D,Euclidean1D> |
Line.getTransform(AffineTransform transform)
Get a Transform embedding an affine transform. |
Uses of MathIllegalArgumentException in org.apache.commons.math3.linear |
---|
Subclasses of MathIllegalArgumentException in org.apache.commons.math3.linear | |
---|---|
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 | |
---|---|
List<CentroidCluster<T>> |
KMeansPlusPlusClusterer.cluster(Collection<T> points)
Runs the K-means++ clustering algorithm. |
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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. |
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.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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 | |
---|---|
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 |
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 |
UnivariateStatistic.evaluate(double[] values)
Returns the result of evaluating the statistic over the input array. |
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 |
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 |
UnivariateStatistic.evaluate(double[] values,
int begin,
int length)
Returns the result of evaluating the statistic over the specified entries in the input array. |
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 |
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. |
Constructors in org.apache.commons.math3.stat.descriptive that throw MathIllegalArgumentException | |
---|---|
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 | |
---|---|
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 |
StandardDeviation.evaluate(double[] values,
double mean)
Returns the Standard Deviation 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 |
Variance.evaluate(double[] values,
double[] weights)
Returns the weighted variance of the entries in the the input array. |
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,
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 |
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 |
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 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 |
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 |
GeometricMean.evaluate(double[] values,
int begin,
int length)
Returns the geometric mean of the entries in the specified 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.NaN if 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 |
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 |
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 |
Kurtosis.evaluate(double[] values,
int begin,
int length)
Returns the kurtosis of the entries in the specified portion of the input array. |
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 | |
---|---|
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 |
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 start,
int length)
Returns an estimate of the quantile th percentile of the
designated values in the values array. |
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 | |
---|---|
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 | |
---|---|
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)
The weighted sum of the entries in the the input array. |
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 |
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,
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 |
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 |
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 | |
---|---|
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 | |
---|---|
class |
ModelSpecificationException
Exception thrown when a regression model is not correctly specified. |
Methods in org.apache.commons.math3.stat.regression that throw MathIllegalArgumentException | |
---|---|
double |
OLSMultipleLinearRegression.calculateAdjustedRSquared()
Returns the adjusted R-squared statistic, defined by the formula R2adj = 1 - [SSR (n - 1)] / [SSTO (n - p)] where SSR is the sum of squared residuals ,
SSTO is the total sum of squares , n is the number
of observations and p is the number of parameters estimated (including the intercept). |
double |
OLSMultipleLinearRegression.calculateRSquared()
Returns the R-Squared statistic, defined by the formula R2 = 1 - SSR / SSTO where SSR is the sum of squared residuals
and SSTO is the total sum of squares |
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 | |
---|---|
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 | |
---|---|
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 |
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. |
double |
DefaultTransformer.transform(Object o)
|
Constructors in org.apache.commons.math3.util that throw MathIllegalArgumentException | |
---|---|
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |