| Package | Description |
|---|---|
| org.apache.commons.math3 |
Common classes used throughout the commons-math library.
|
| org.apache.commons.math3.analysis.differentiation |
This package holds the main interfaces and basic building block classes
dealing with differentiation.
|
| org.apache.commons.math3.analysis.function |
The
function package contains function objects that wrap the
methods contained in Math, as well as common
mathematical functions such as the gaussian and sinc functions. |
| org.apache.commons.math3.analysis.integration.gauss |
Gauss family of quadrature schemes.
|
| org.apache.commons.math3.analysis.interpolation |
Univariate real functions interpolation algorithms.
|
| org.apache.commons.math3.analysis.polynomials |
Univariate real polynomials implementations, seen as differentiable
univariate real functions.
|
| org.apache.commons.math3.complex |
Complex number type and implementations of complex transcendental
functions.
|
| org.apache.commons.math3.dfp |
Decimal floating point library for Java
|
| org.apache.commons.math3.distribution |
Implementations of common discrete and continuous distributions.
|
| org.apache.commons.math3.distribution.fitting |
Fitting of parameters against distributions.
|
| org.apache.commons.math3.filter |
Implementations of common discrete-time linear filters.
|
| org.apache.commons.math3.genetics |
This package provides Genetic Algorithms components and implementations.
|
| org.apache.commons.math3.geometry.euclidean.threed |
This package provides basic 3D geometry components.
|
| org.apache.commons.math3.geometry.euclidean.twod |
This package provides basic 2D geometry components.
|
| org.apache.commons.math3.linear |
Linear algebra support.
|
| org.apache.commons.math3.ml.distance |
Common distance measures.
|
| org.apache.commons.math3.ode |
This package provides classes to solve Ordinary Differential Equations problems.
|
| org.apache.commons.math3.ode.nonstiff |
This package provides classes to solve non-stiff Ordinary Differential Equations problems.
|
| org.apache.commons.math3.optim.nonlinear.scalar.noderiv |
This package provides optimization algorithms that do not require derivatives.
|
| org.apache.commons.math3.optim.nonlinear.vector |
Algorithms for optimizing a vector function.
|
| org.apache.commons.math3.optimization.direct |
This package provides optimization algorithms that don't require derivatives.
|
| org.apache.commons.math3.random |
Random number and random data generators.
|
| org.apache.commons.math3.stat |
Data storage, manipulation and summary routines.
|
| org.apache.commons.math3.stat.correlation |
Correlations/Covariance computations.
|
| org.apache.commons.math3.stat.descriptive |
Generic univariate summary statistic objects.
|
| org.apache.commons.math3.stat.descriptive.moment |
Summary statistics based on moments.
|
| org.apache.commons.math3.stat.inference |
Classes providing hypothesis testing.
|
| org.apache.commons.math3.transform |
Implementations of transform methods, including Fast Fourier transforms.
|
| org.apache.commons.math3.util |
Convenience routines and common data structures used throughout the commons-math library.
|
| Modifier and Type | Method and Description |
|---|---|
T |
RealFieldElement.atan2(T x)
Two arguments arc tangent operation.
|
T |
RealFieldElement.hypot(T y)
Returns the hypotenuse of a triangle with sides
this and y
- sqrt(this2 +y2)
avoiding intermediate overflow or underflow. |
T |
RealFieldElement.linearCombination(double[] a,
T[] b)
Compute a linear combination.
|
T |
RealFieldElement.linearCombination(T[] a,
T[] b)
Compute a linear combination.
|
T |
RealFieldElement.pow(T e)
Power operation.
|
T |
RealFieldElement.remainder(T a)
IEEE remainder operator.
|
| Modifier and Type | Method and Description |
|---|---|
DerivativeStructure |
DerivativeStructure.add(DerivativeStructure a)
Compute this + a.
|
DerivativeStructure |
DerivativeStructure.atan2(DerivativeStructure x)
Two arguments arc tangent operation.
|
static DerivativeStructure |
DerivativeStructure.atan2(DerivativeStructure y,
DerivativeStructure x)
Two arguments arc tangent operation.
|
void |
DSCompiler.checkCompatibility(DSCompiler compiler)
Check rules set compatibility.
|
DerivativeStructure |
DerivativeStructure.compose(double... f)
Compute composition of the instance by a univariate function.
|
DerivativeStructure |
DerivativeStructure.divide(DerivativeStructure a)
Compute this ÷ a.
|
double |
DerivativeStructure.getPartialDerivative(int... orders)
Get a partial derivative.
|
int |
DSCompiler.getPartialDerivativeIndex(int... orders)
Get the index of a partial derivative in the array.
|
DerivativeStructure |
DerivativeStructure.hypot(DerivativeStructure y)
Returns the hypotenuse of a triangle with sides
this and y
- sqrt(this2 +y2)
avoiding intermediate overflow or underflow. |
static DerivativeStructure |
DerivativeStructure.hypot(DerivativeStructure x,
DerivativeStructure y)
Returns the hypotenuse of a triangle with sides
x and y
- sqrt(x2 +y2)
avoiding intermediate overflow or underflow. |
DerivativeStructure |
DerivativeStructure.linearCombination(DerivativeStructure[] a,
DerivativeStructure[] b)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(DerivativeStructure a1,
DerivativeStructure b1,
DerivativeStructure a2,
DerivativeStructure b2)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(DerivativeStructure a1,
DerivativeStructure b1,
DerivativeStructure a2,
DerivativeStructure b2,
DerivativeStructure a3,
DerivativeStructure b3)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(DerivativeStructure a1,
DerivativeStructure b1,
DerivativeStructure a2,
DerivativeStructure b2,
DerivativeStructure a3,
DerivativeStructure b3,
DerivativeStructure a4,
DerivativeStructure b4)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(double[] a,
DerivativeStructure[] b)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(double a1,
DerivativeStructure b1,
double a2,
DerivativeStructure b2)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(double a1,
DerivativeStructure b1,
double a2,
DerivativeStructure b2,
double a3,
DerivativeStructure b3)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.linearCombination(double a1,
DerivativeStructure b1,
double a2,
DerivativeStructure b2,
double a3,
DerivativeStructure b3,
double a4,
DerivativeStructure b4)
Compute a linear combination.
|
SparseGradient |
SparseGradient.linearCombination(SparseGradient[] a,
SparseGradient[] b)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.multiply(DerivativeStructure a)
Compute this × a.
|
DerivativeStructure |
DerivativeStructure.pow(DerivativeStructure e)
Power operation.
|
DerivativeStructure |
DerivativeStructure.remainder(DerivativeStructure a)
IEEE remainder operator.
|
DerivativeStructure |
DerivativeStructure.subtract(DerivativeStructure a)
Compute this - a.
|
DerivativeStructure |
UnivariateDifferentiableFunction.value(DerivativeStructure t)
Simple mathematical function.
|
| Constructor and Description |
|---|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2)
Linear combination constructor.
|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2,
double a3,
DerivativeStructure ds3)
Linear combination constructor.
|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2,
double a3,
DerivativeStructure ds3,
double a4,
DerivativeStructure ds4)
Linear combination constructor.
|
DerivativeStructure(int parameters,
int order,
double... derivatives)
Build an instance from all its derivatives.
|
| Modifier and Type | Method and Description |
|---|---|
double[] |
Logit.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
double[] |
Logistic.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
double[] |
HarmonicOscillator.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
double[] |
Sigmoid.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
double[] |
Gaussian.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
DerivativeStructure |
HarmonicOscillator.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Sigmoid.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Gaussian.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Sinc.value(DerivativeStructure t)
Simple mathematical function.
|
double |
Logit.Parametric.value(double x,
double... param)
Computes the value of the logit at
x. |
double |
Logistic.Parametric.value(double x,
double... param)
Computes the value of the sigmoid at
x. |
double |
HarmonicOscillator.Parametric.value(double x,
double... param)
Computes the value of the harmonic oscillator at
x. |
double |
Sigmoid.Parametric.value(double x,
double... param)
Computes the value of the sigmoid at
x. |
double |
Gaussian.Parametric.value(double x,
double... param)
Computes the value of the Gaussian at
x. |
| Constructor and Description |
|---|
StepFunction(double[] x,
double[] y)
Builds a step function from a list of arguments and the corresponding
values.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
BaseRuleFactory.addRule(Pair<T[],T[]> rule)
Stores a rule.
|
protected Pair<BigDecimal[],BigDecimal[]> |
LegendreHighPrecisionRuleFactory.computeRule(int numberOfPoints)
Computes the rule for the given order.
|
protected Pair<Double[],Double[]> |
LegendreRuleFactory.computeRule(int numberOfPoints)
Computes the rule for the given order.
|
protected Pair<Double[],Double[]> |
HermiteRuleFactory.computeRule(int numberOfPoints)
Computes the rule for the given order.
|
protected abstract Pair<T[],T[]> |
BaseRuleFactory.computeRule(int numberOfPoints)
Computes the rule for the given order.
|
Pair<double[],double[]> |
BaseRuleFactory.getRule(int numberOfPoints)
Gets a copy of the quadrature rule with the given number of integration
points.
|
protected Pair<T[],T[]> |
BaseRuleFactory.getRuleInternal(int numberOfPoints)
Gets a rule.
|
| Constructor and Description |
|---|
GaussIntegrator(double[] points,
double[] weights)
Creates an integrator from the given
points and weights. |
SymmetricGaussIntegrator(double[] points,
double[] weights)
Creates an integrator from the given
points and weights. |
| Modifier and Type | Method and Description |
|---|---|
void |
FieldHermiteInterpolator.addSamplePoint(T x,
T[]... value)
Add a sample point.
|
protected static double[] |
DividedDifferenceInterpolator.computeDividedDifference(double[] x,
double[] y)
Return a copy of the divided difference array.
|
MultivariateFunction |
MultivariateInterpolator.interpolate(double[][] xval,
double[] yval)
Computes an interpolating function for the data set.
|
MultivariateFunction |
MicrosphereInterpolator.interpolate(double[][] xval,
double[] yval)
Deprecated.
Computes an interpolating function for the data set.
|
MultivariateFunction |
MicrosphereProjectionInterpolator.interpolate(double[][] xval,
double[] yval)
Computes an interpolating function for the data set.
|
PolynomialSplineFunction |
LinearInterpolator.interpolate(double[] x,
double[] y)
Computes a linear interpolating function for the data set.
|
UnivariateFunction |
UnivariateInterpolator.interpolate(double[] xval,
double[] yval)
Compute an interpolating function for the dataset.
|
PolynomialFunctionLagrangeForm |
NevilleInterpolator.interpolate(double[] x,
double[] y)
Computes an interpolating function for the data set.
|
PolynomialSplineFunction |
AkimaSplineInterpolator.interpolate(double[] xvals,
double[] yvals)
Computes an interpolating function for the data set.
|
PolynomialSplineFunction |
SplineInterpolator.interpolate(double[] x,
double[] y)
Computes an interpolating function for the data set.
|
PolynomialFunctionNewtonForm |
DividedDifferenceInterpolator.interpolate(double[] x,
double[] y)
Compute an interpolating function for the dataset.
|
PolynomialSplineFunction |
LoessInterpolator.interpolate(double[] xval,
double[] yval)
Compute an interpolating function by performing a loess fit
on the data at the original abscissae and then building a cubic spline
with a
SplineInterpolator
on the resulting fit. |
BicubicSplineInterpolatingFunction |
SmoothingPolynomialBicubicSplineInterpolator.interpolate(double[] xval,
double[] yval,
double[][] fval)
Deprecated.
Compute an interpolating function for the dataset.
|
BicubicInterpolatingFunction |
BicubicInterpolator.interpolate(double[] xval,
double[] yval,
double[][] fval)
Compute an interpolating function for the dataset.
|
BicubicSplineInterpolatingFunction |
BicubicSplineInterpolator.interpolate(double[] xval,
double[] yval,
double[][] fval)
Deprecated.
Compute an interpolating function for the dataset.
|
PiecewiseBicubicSplineInterpolatingFunction |
PiecewiseBicubicSplineInterpolator.interpolate(double[] xval,
double[] yval,
double[][] fval)
Compute an interpolating function for the dataset.
|
BivariateFunction |
BivariateGridInterpolator.interpolate(double[] xval,
double[] yval,
double[][] fval)
Compute an interpolating function for the dataset.
|
TricubicInterpolatingFunction |
TricubicInterpolator.interpolate(double[] xval,
double[] yval,
double[] zval,
double[][][] fval)
Compute an interpolating function for the dataset.
|
TrivariateFunction |
TrivariateGridInterpolator.interpolate(double[] xval,
double[] yval,
double[] zval,
double[][][] fval)
Compute an interpolating function for the dataset.
|
TricubicSplineInterpolatingFunction |
TricubicSplineInterpolator.interpolate(double[] xval,
double[] yval,
double[] zval,
double[][][] fval)
Deprecated.
Compute an interpolating function for the dataset.
|
double[] |
LoessInterpolator.smooth(double[] xval,
double[] yval)
Compute a loess fit on the data at the original abscissae.
|
double[] |
LoessInterpolator.smooth(double[] xval,
double[] yval,
double[] weights)
Compute a weighted loess fit on the data at the original abscissae.
|
double |
MicrosphereInterpolatingFunction.value(double[] point)
Deprecated.
|
| Constructor and Description |
|---|
BicubicInterpolatingFunction(double[] x,
double[] y,
double[][] f,
double[][] dFdX,
double[][] dFdY,
double[][] d2FdXdY) |
BicubicSplineInterpolatingFunction(double[] x,
double[] y,
double[][] f,
double[][] dFdX,
double[][] dFdY,
double[][] d2FdXdY)
Deprecated.
|
BicubicSplineInterpolatingFunction(double[] x,
double[] y,
double[][] f,
double[][] dFdX,
double[][] dFdY,
double[][] d2FdXdY,
boolean initializeDerivatives)
Deprecated.
|
MicrosphereInterpolatingFunction(double[][] xval,
double[] yval,
int brightnessExponent,
int microsphereElements,
UnitSphereRandomVectorGenerator rand)
Deprecated.
|
PiecewiseBicubicSplineInterpolatingFunction(double[] x,
double[] y,
double[][] f) |
TricubicInterpolatingFunction(double[] x,
double[] y,
double[] z,
double[][][] f,
double[][][] dFdX,
double[][][] dFdY,
double[][][] dFdZ,
double[][][] d2FdXdY,
double[][][] d2FdXdZ,
double[][][] d2FdYdZ,
double[][][] d3FdXdYdZ) |
TricubicSplineInterpolatingFunction(double[] x,
double[] y,
double[] z,
double[][][] f,
double[][][] dFdX,
double[][][] dFdY,
double[][][] dFdZ,
double[][][] d2FdXdY,
double[][][] d2FdXdZ,
double[][][] d2FdYdZ,
double[][][] d3FdXdYdZ)
Deprecated.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
PolynomialFunctionLagrangeForm.evaluate(double[] x,
double[] y,
double z)
Evaluate the Lagrange polynomial using
Neville's Algorithm.
|
static double |
PolynomialFunctionNewtonForm.evaluate(double[] a,
double[] c,
double z)
Evaluate the Newton polynomial using nested multiplication.
|
protected static void |
PolynomialFunctionNewtonForm.verifyInputArray(double[] a,
double[] c)
Verifies that the input arrays are valid.
|
static boolean |
PolynomialFunctionLagrangeForm.verifyInterpolationArray(double[] x,
double[] y,
boolean abort)
Check that the interpolation arrays are valid.
|
| Constructor and Description |
|---|
PolynomialFunctionLagrangeForm(double[] x,
double[] y)
Construct a Lagrange polynomial with the given abscissas and function
values.
|
PolynomialFunctionNewtonForm(double[] a,
double[] c)
Construct a Newton polynomial with the given a[] and c[].
|
PolynomialSplineFunction(double[] knots,
PolynomialFunction[] polynomials)
Construct a polynomial spline function with the given segment delimiters
and interpolating polynomials.
|
| Constructor and Description |
|---|
Quaternion(double scalar,
double[] v)
Builds a quaternion from scalar and vector parts.
|
| Modifier and Type | Method and Description |
|---|---|
Dfp |
Dfp.atan2(Dfp x)
Two arguments arc tangent operation.
|
Dfp |
Dfp.linearCombination(Dfp[] a,
Dfp[] b)
Compute a linear combination.
|
Dfp |
Dfp.linearCombination(double[] a,
Dfp[] b)
Compute a linear combination.
|
| Modifier and Type | Method and Description |
|---|---|
double |
MultivariateNormalDistribution.density(double[] vals)
Returns the probability density function (PDF) of this distribution
evaluated at the specified point
x. |
| Constructor and Description |
|---|
EnumeratedIntegerDistribution(int[] singletons,
double[] probabilities)
Create a discrete distribution using the given probability mass function
definition.
|
EnumeratedIntegerDistribution(RandomGenerator rng,
int[] singletons,
double[] probabilities)
Create a discrete distribution using the given random number generator
and probability mass function definition.
|
EnumeratedRealDistribution(double[] singletons,
double[] probabilities)
Create a discrete real-valued distribution using the given probability mass function
enumeration.
|
EnumeratedRealDistribution(RandomGenerator rng,
double[] singletons,
double[] probabilities)
Create a discrete real-valued distribution using the given random number generator
and probability mass function enumeration.
|
MixtureMultivariateNormalDistribution(RandomGenerator rng,
List<Pair<Double,MultivariateNormalDistribution>> components)
Creates a mixture model from a list of distributions and their
associated weights.
|
MultivariateNormalDistribution(double[] means,
double[][] covariances)
Creates a multivariate normal distribution with the given mean vector and
covariance matrix.
|
MultivariateNormalDistribution(RandomGenerator rng,
double[] means,
double[][] covariances)
Creates a multivariate normal distribution with the given mean vector and
covariance matrix.
|
| Modifier and Type | Method and Description |
|---|---|
static MixtureMultivariateNormalDistribution |
MultivariateNormalMixtureExpectationMaximization.estimate(double[][] data,
int numComponents)
Helper method to create a multivariate normal mixture model which can be
used to initialize
MultivariateNormalMixtureExpectationMaximization.fit(MixtureMultivariateNormalDistribution). |
void |
MultivariateNormalMixtureExpectationMaximization.fit(MixtureMultivariateNormalDistribution initialMixture,
int maxIterations,
double threshold)
Fit a mixture model to the data supplied to the constructor.
|
| Constructor and Description |
|---|
MultivariateNormalMixtureExpectationMaximization(double[][] data)
Creates an object to fit a multivariate normal mixture model to data.
|
| Modifier and Type | Method and Description |
|---|---|
void |
KalmanFilter.correct(double[] z)
Correct the current state estimate with an actual measurement.
|
void |
KalmanFilter.correct(RealVector z)
Correct the current state estimate with an actual measurement.
|
void |
KalmanFilter.predict(double[] u)
Predict the internal state estimation one time step ahead.
|
void |
KalmanFilter.predict(RealVector u)
Predict the internal state estimation one time step ahead.
|
| Constructor and Description |
|---|
DefaultMeasurementModel(double[][] measMatrix,
double[][] measNoise)
Create a new
MeasurementModel, taking double arrays as input parameters for the
respective measurement matrix and noise. |
DefaultProcessModel(double[][] stateTransition,
double[][] control,
double[][] processNoise)
Create a new
ProcessModel, taking double arrays as input parameters. |
DefaultProcessModel(double[][] stateTransition,
double[][] control,
double[][] processNoise,
double[] initialStateEstimate,
double[][] initialErrorCovariance)
Create a new
ProcessModel, taking double arrays as input parameters. |
KalmanFilter(ProcessModel process,
MeasurementModel measurement)
Creates a new Kalman filter with the given process and measurement models.
|
| Modifier and Type | Method and Description |
|---|---|
ChromosomePair |
OnePointCrossover.crossover(Chromosome first,
Chromosome second)
Performs one point crossover.
|
ChromosomePair |
CycleCrossover.crossover(Chromosome first,
Chromosome second)
Perform a crossover operation on the given chromosomes.
|
ChromosomePair |
NPointCrossover.crossover(Chromosome first,
Chromosome second)
Performs a N-point crossover.
|
ChromosomePair |
OrderedCrossover.crossover(Chromosome first,
Chromosome second)
Perform a crossover operation on the given chromosomes.
|
ChromosomePair |
UniformCrossover.crossover(Chromosome first,
Chromosome second)
Perform a crossover operation on the given chromosomes.
|
static <S> List<Double> |
RandomKey.inducedPermutation(List<S> originalData,
List<S> permutedData)
Generates a representation of a permutation corresponding to a
permutation which yields
permutedData when applied to
originalData. |
protected ChromosomePair |
CycleCrossover.mate(AbstractListChromosome<T> first,
AbstractListChromosome<T> second)
Helper for
CycleCrossover.crossover(Chromosome, Chromosome). |
protected ChromosomePair |
OrderedCrossover.mate(AbstractListChromosome<T> first,
AbstractListChromosome<T> second)
|
| Constructor and Description |
|---|
FieldVector3D(T[] v)
Simple constructor.
|
Vector3D(double[] v)
Simple constructor.
|
| Constructor and Description |
|---|
Vector2D(double[] v)
Simple constructor.
|
| Modifier and Type | Class and Description |
|---|---|
class |
NonSquareMatrixException
Exception to be thrown when a square matrix is expected.
|
class |
NonSquareOperatorException
Exception to be thrown when a square linear operator is expected.
|
| Modifier and Type | Method and Description |
|---|---|
ArrayFieldVector<T> |
ArrayFieldVector.add(ArrayFieldVector<T> v)
Compute the sum of
this and v. |
FieldVector<T> |
FieldVector.add(FieldVector<T> v)
Compute the sum of
this and v. |
FieldVector<T> |
SparseFieldVector.add(FieldVector<T> v)
Compute the sum of
this and v. |
FieldVector<T> |
ArrayFieldVector.add(FieldVector<T> v)
Compute the sum of
this and v. |
OpenMapRealVector |
OpenMapRealVector.add(OpenMapRealVector v)
Optimized method to add two OpenMapRealVectors.
|
RealVector |
RealVector.add(RealVector v)
Compute the sum of this vector and
v. |
RealVector |
OpenMapRealVector.add(RealVector v)
Compute the sum of this vector and
v. |
ArrayRealVector |
ArrayRealVector.add(RealVector v)
Compute the sum of this vector and
v. |
FieldVector<T> |
SparseFieldVector.add(SparseFieldVector<T> v)
Optimized method to add sparse vectors.
|
static void |
MatrixUtils.checkMultiplicationCompatible(AnyMatrix left,
AnyMatrix right)
Check if matrices are multiplication compatible
|
protected void |
AbstractFieldMatrix.checkMultiplicationCompatible(FieldMatrix<T> m)
Check if a matrix is multiplication compatible with the instance.
|
protected static void |
PreconditionedIterativeLinearSolver.checkParameters(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x0)
Performs all dimension checks on the parameters of
solve
and
solveInPlace,
and throws an exception if one of the checks fails. |
protected static void |
IterativeLinearSolver.checkParameters(RealLinearOperator a,
RealVector b,
RealVector x0)
Performs all dimension checks on the parameters of
solve and
solveInPlace,
and throws an exception if one of the checks fails. |
protected void |
ArrayFieldVector.checkVectorDimensions(FieldVector<T> v)
Check if instance and specified vectors have the same dimension.
|
protected void |
RealVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
ArrayRealVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
SparseFieldVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
ArrayFieldVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
RealVector.checkVectorDimensions(RealVector v)
Check if instance and specified vectors have the same dimension.
|
protected void |
ArrayRealVector.checkVectorDimensions(RealVector v)
Check if instance and specified vectors have the same dimension.
|
RealVector |
RealVector.combine(double a,
double b,
RealVector y)
Returns a new vector representing
a * this + b * y, the linear
combination of this and y. |
ArrayRealVector |
ArrayRealVector.combine(double a,
double b,
RealVector y)
Returns a new vector representing
a * this + b * y, the linear
combination of this and y. |
RealVector |
RealVector.combineToSelf(double a,
double b,
RealVector y)
Updates
this with the linear combination of this and
y. |
ArrayRealVector |
ArrayRealVector.combineToSelf(double a,
double b,
RealVector y)
Updates
this with the linear combination of this and
y. |
double |
RealVector.cosine(RealVector v)
Computes the cosine of the angle between this vector and the
argument.
|
static <T extends FieldElement<T>> |
MatrixUtils.createFieldMatrix(T[][] data)
Returns a
FieldMatrix whose entries are the the values in the
the input array. |
RealMatrix |
DiagonalMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix of the same type as the instance with the
supplied
row and column dimensions.
|
static RealMatrix |
MatrixUtils.createRealMatrix(double[][] data)
Returns a
RealMatrix whose entries are the the values in the
the input array. |
T |
ArrayFieldVector.dotProduct(ArrayFieldVector<T> v)
Compute the dot product.
|
T |
FieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
T |
SparseFieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
T |
ArrayFieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
double |
OpenMapRealVector.dotProduct(OpenMapRealVector v)
Deprecated.
as of 3.1 (to be removed in 4.0). The computation is
performed by the parent class. The method must be kept to maintain
backwards compatibility.
|
double |
RealVector.dotProduct(RealVector v)
Compute the dot product of this vector with
v. |
double |
ArrayRealVector.dotProduct(RealVector v)
Compute the dot product of this vector with
v. |
ArrayFieldVector<T> |
ArrayFieldVector.ebeDivide(ArrayFieldVector<T> v)
Element-by-element division.
|
FieldVector<T> |
FieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
FieldVector<T> |
SparseFieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
FieldVector<T> |
ArrayFieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
abstract RealVector |
RealVector.ebeDivide(RealVector v)
Element-by-element division.
|
OpenMapRealVector |
OpenMapRealVector.ebeDivide(RealVector v)
Element-by-element division.
|
ArrayRealVector |
ArrayRealVector.ebeDivide(RealVector v)
Element-by-element division.
|
ArrayFieldVector<T> |
ArrayFieldVector.ebeMultiply(ArrayFieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
FieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
SparseFieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
ArrayFieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
abstract RealVector |
RealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
OpenMapRealVector |
OpenMapRealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
ArrayRealVector |
ArrayRealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
double |
OpenMapRealVector.getDistance(OpenMapRealVector v)
Optimized method to compute distance.
|
double |
RealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
ArrayRealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getL1Distance(OpenMapRealVector v)
Distance between two vectors.
|
double |
RealVector.getL1Distance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getL1Distance(RealVector v)
Distance between two vectors.
|
double |
ArrayRealVector.getL1Distance(RealVector v)
Distance between two vectors.
|
double |
RealVector.getLInfDistance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getLInfDistance(RealVector v)
Distance between two vectors.
|
double |
ArrayRealVector.getLInfDistance(RealVector v)
Distance between two vectors.
|
Array2DRowFieldMatrix<T> |
Array2DRowFieldMatrix.multiply(Array2DRowFieldMatrix<T> m)
Postmultiplying this matrix by
m. |
Array2DRowRealMatrix |
Array2DRowRealMatrix.multiply(Array2DRowRealMatrix m)
Returns the result of postmultiplying
this by m. |
BlockFieldMatrix<T> |
BlockFieldMatrix.multiply(BlockFieldMatrix<T> m)
Returns the result of postmultiplying
this by m. |
BlockRealMatrix |
BlockRealMatrix.multiply(BlockRealMatrix m)
Returns the result of postmultiplying this by
m. |
DiagonalMatrix |
DiagonalMatrix.multiply(DiagonalMatrix m)
Returns the result of postmultiplying
this by m. |
FieldMatrix<T> |
AbstractFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
FieldMatrix<T> |
BlockFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
FieldMatrix<T> |
FieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
OpenMapRealMatrix |
OpenMapRealMatrix.multiply(OpenMapRealMatrix m)
Postmultiply this matrix by
m. |
RealMatrix |
DiagonalMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
BlockRealMatrix |
BlockRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
RealMatrix |
AbstractRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
RealMatrix |
RealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
RealMatrix |
OpenMapRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
double[] |
DiagonalMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
double[] |
BlockRealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
double[] |
AbstractRealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
double[] |
RealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
double[] |
Array2DRowRealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
FieldVector<T> |
AbstractFieldMatrix.operate(FieldVector<T> v)
Returns the result of multiplying this by the vector
v. |
FieldVector<T> |
FieldMatrix.operate(FieldVector<T> v)
Returns the result of multiplying this by the vector
v. |
abstract RealVector |
RealLinearOperator.operate(RealVector x)
Returns the result of multiplying
this by the vector x. |
RealVector |
AbstractRealMatrix.operate(RealVector v)
Returns the result of multiplying
this by the vector x. |
RealVector |
RealMatrix.operate(RealVector v)
Returns the result of multiplying this by the vector
v. |
T[] |
Array2DRowFieldMatrix.operate(T[] v)
Returns the result of multiplying this by the vector
v. |
T[] |
AbstractFieldMatrix.operate(T[] v)
Returns the result of multiplying this by the vector
v. |
T[] |
BlockFieldMatrix.operate(T[] v)
Returns the result of multiplying this by the vector
v. |
T[] |
FieldMatrix.operate(T[] v)
Returns the result of multiplying this by the vector
v. |
RealVector |
RealLinearOperator.operateTranspose(RealVector x)
Returns the result of multiplying the transpose of
this operator
by the vector x (optional operation). |
double[] |
DiagonalMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
double[] |
BlockRealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
double[] |
AbstractRealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
double[] |
RealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
double[] |
Array2DRowRealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
FieldMatrix<T> |
AbstractFieldMatrix.preMultiply(FieldMatrix<T> m)
Premultiply this matrix by
m. |
FieldMatrix<T> |
FieldMatrix.preMultiply(FieldMatrix<T> m)
Premultiply this matrix by
m. |
FieldVector<T> |
AbstractFieldMatrix.preMultiply(FieldVector<T> v)
Returns the (row) vector result of premultiplying this by the vector
v. |
FieldVector<T> |
FieldMatrix.preMultiply(FieldVector<T> v)
Returns the (row) vector result of premultiplying this by the vector
v. |
RealMatrix |
AbstractRealMatrix.preMultiply(RealMatrix m)
Returns the result of premultiplying
this by m. |
RealMatrix |
RealMatrix.preMultiply(RealMatrix m)
Returns the result of premultiplying
this by m. |
RealVector |
DiagonalMatrix.preMultiply(RealVector v)
Returns the (row) vector result of premultiplying this by the vector
v. |
RealVector |
AbstractRealMatrix.preMultiply(RealVector v)
Returns the (row) vector result of premultiplying this by the vector
v. |
RealVector |
RealMatrix.preMultiply(RealVector v)
Returns the (row) vector result of premultiplying this by the vector
v. |
T[] |
Array2DRowFieldMatrix.preMultiply(T[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
T[] |
AbstractFieldMatrix.preMultiply(T[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
T[] |
BlockFieldMatrix.preMultiply(T[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
T[] |
FieldMatrix.preMultiply(T[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
ArrayFieldVector<T> |
ArrayFieldVector.projection(ArrayFieldVector<T> v)
Find the orthogonal projection of this vector onto another vector.
|
FieldVector<T> |
FieldVector.projection(FieldVector<T> v)
Find the orthogonal projection of this vector onto another vector.
|
FieldVector<T> |
SparseFieldVector.projection(FieldVector<T> v)
Find the orthogonal projection of this vector onto another vector.
|
FieldVector<T> |
ArrayFieldVector.projection(FieldVector<T> v)
Find the orthogonal projection of this vector onto another vector.
|
RealVector |
RealVector.projection(RealVector v)
Find the orthogonal projection of this vector onto another vector.
|
void |
BlockRealMatrix.setSubMatrix(double[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
row, column using data in the
input subMatrix array. |
void |
AbstractRealMatrix.setSubMatrix(double[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
row, column using data in the
input subMatrix array. |
void |
RealMatrix.setSubMatrix(double[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
row, column using data in the
input subMatrix array. |
void |
Array2DRowRealMatrix.setSubMatrix(double[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
row, column using data in the
input subMatrix array. |
void |
Array2DRowFieldMatrix.setSubMatrix(T[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
(row, column) using data in the
input subMatrix array. |
void |
AbstractFieldMatrix.setSubMatrix(T[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
(row, column) using data in the
input subMatrix array. |
void |
BlockFieldMatrix.setSubMatrix(T[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
(row, column) using data in the
input subMatrix array. |
void |
FieldMatrix.setSubMatrix(T[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
(row, column) using data in the
input subMatrix array. |
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealLinearOperator m,
RealVector b)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
PreconditionedIterativeLinearSolver.solve(RealLinearOperator a,
RealLinearOperator m,
RealVector b)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
boolean goodb,
double shift)
Returns an estimate of the solution to the linear system (A - shift
· I) · x = b.
|
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
PreconditionedIterativeLinearSolver.solve(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealVector b)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
IterativeLinearSolver.solve(RealLinearOperator a,
RealVector b)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
PreconditionedIterativeLinearSolver.solve(RealLinearOperator a,
RealVector b)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealVector b,
boolean goodb,
double shift)
Returns the solution to the system (A - shift · I) · x = b.
|
RealVector |
SymmLQ.solve(RealLinearOperator a,
RealVector b,
RealVector x)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
IterativeLinearSolver.solve(RealLinearOperator a,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
PreconditionedIterativeLinearSolver.solve(RealLinearOperator a,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
SymmLQ.solveInPlace(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
ConjugateGradient.solveInPlace(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
abstract RealVector |
PreconditionedIterativeLinearSolver.solveInPlace(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
SymmLQ.solveInPlace(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x,
boolean goodb,
double shift)
Returns an estimate of the solution to the linear system (A - shift
· I) · x = b.
|
RealVector |
SymmLQ.solveInPlace(RealLinearOperator a,
RealVector b,
RealVector x)
Returns an estimate of the solution to the linear system A · x =
b.
|
abstract RealVector |
IterativeLinearSolver.solveInPlace(RealLinearOperator a,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
RealVector |
PreconditionedIterativeLinearSolver.solveInPlace(RealLinearOperator a,
RealVector b,
RealVector x0)
Returns an estimate of the solution to the linear system A · x =
b.
|
static void |
MatrixUtils.solveLowerTriangularSystem(RealMatrix rm,
RealVector b)
Solve a system of composed of a Lower Triangular Matrix
RealMatrix. |
static void |
MatrixUtils.solveUpperTriangularSystem(RealMatrix rm,
RealVector b)
Solver a system composed of an Upper Triangular Matrix
RealMatrix. |
ArrayFieldVector<T> |
ArrayFieldVector.subtract(ArrayFieldVector<T> v)
Compute
this minus v. |
FieldVector<T> |
FieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
FieldVector<T> |
SparseFieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
FieldVector<T> |
ArrayFieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
OpenMapRealVector |
OpenMapRealVector.subtract(OpenMapRealVector v)
Optimized method to subtract OpenMapRealVectors.
|
RealVector |
RealVector.subtract(RealVector v)
Subtract
v from this vector. |
RealVector |
OpenMapRealVector.subtract(RealVector v)
Subtract
v from this vector. |
ArrayRealVector |
ArrayRealVector.subtract(RealVector v)
Subtract
v from this vector. |
SparseFieldVector<T> |
SparseFieldVector.subtract(SparseFieldVector<T> v)
Optimized method to compute
this minus v. |
static double[][] |
BlockRealMatrix.toBlocksLayout(double[][] rawData)
Convert a data array from raw layout to blocks layout.
|
static <T extends FieldElement<T>> |
BlockFieldMatrix.toBlocksLayout(T[][] rawData)
Convert a data array from raw layout to blocks layout.
|
| Constructor and Description |
|---|
Array2DRowFieldMatrix(Field<T> field,
T[][] d)
Create a new
FieldMatrix<T> using the input array as the underlying
data array. |
Array2DRowFieldMatrix(Field<T> field,
T[][] d,
boolean copyArray)
Create a new
FieldMatrix<T> using the input array as the underlying
data array. |
Array2DRowFieldMatrix(T[][] d)
Create a new
FieldMatrix<T> using the input array as the underlying
data array. |
Array2DRowFieldMatrix(T[][] d,
boolean copyArray)
Create a new
FieldMatrix<T> using the input array as the underlying
data array. |
Array2DRowRealMatrix(double[][] d)
Create a new
RealMatrix using the input array as the underlying
data array. |
Array2DRowRealMatrix(double[][] d,
boolean copyArray)
Create a new RealMatrix using the input array as the underlying
data array.
|
BlockFieldMatrix(int rows,
int columns,
T[][] blockData,
boolean copyArray)
Create a new dense matrix copying entries from block layout data.
|
BlockFieldMatrix(T[][] rawData)
Create a new dense matrix copying entries from raw layout data.
|
BlockRealMatrix(double[][] rawData)
Create a new dense matrix copying entries from raw layout data.
|
BlockRealMatrix(int rows,
int columns,
double[][] blockData,
boolean copyArray)
Create a new dense matrix copying entries from block layout data.
|
| Modifier and Type | Method and Description |
|---|---|
double |
ChebyshevDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
ManhattanDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
CanberraDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
DistanceMeasure.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
EuclideanDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
EarthMoversDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
| Modifier and Type | Method and Description |
|---|---|
protected FieldODEStateAndDerivative<T> |
AbstractFieldIntegrator.acceptStep(AbstractFieldStepInterpolator<T> interpolator,
T tEnd)
Accept a step, triggering events and step handlers.
|
protected double |
AbstractIntegrator.acceptStep(AbstractStepInterpolator interpolator,
double[] y,
double[] yDot,
double tEnd)
Accept a step, triggering events and step handlers.
|
void |
FirstOrderDifferentialEquations.computeDerivatives(double t,
double[] y,
double[] yDot)
Get the current time derivative of the state vector.
|
void |
ExpandableStatefulODE.computeDerivatives(double t,
double[] y,
double[] yDot)
Get the current time derivative of the complete state vector.
|
void |
AbstractIntegrator.computeDerivatives(double t,
double[] y,
double[] yDot)
Compute the derivatives and check the number of evaluations.
|
void |
SecondaryEquations.computeDerivatives(double t,
double[] primary,
double[] primaryDot,
double[] secondary,
double[] secondaryDot)
Compute the derivatives related to the secondary state parameters.
|
T[] |
AbstractFieldIntegrator.computeDerivatives(T t,
T[] y)
Compute the derivatives and check the number of evaluations.
|
T[] |
FieldExpandableODE.computeDerivatives(T t,
T[] y)
Get the current time derivative of the complete state vector.
|
T[] |
FieldSecondaryEquations.computeDerivatives(T t,
T[] primary,
T[] primaryDot,
T[] secondary)
Compute the derivatives related to the secondary state parameters.
|
void |
MainStateJacobianProvider.computeMainStateJacobian(double t,
double[] y,
double[] yDot,
double[][] dFdY)
Compute the jacobian matrix of ODE with respect to main state.
|
void |
ParameterJacobianProvider.computeParameterJacobian(double t,
double[] y,
double[] yDot,
String paramName,
double[] dFdP)
Compute the Jacobian matrix of ODE with respect to one parameter.
|
void |
EquationsMapper.extractEquationData(double[] complete,
double[] equationData)
Extract equation data from a complete state or derivative array.
|
T[] |
FieldEquationsMapper.extractEquationData(int index,
T[] complete)
Extract equation data from a complete state or derivative array.
|
double[] |
ExpandableStatefulODE.getCompleteState()
Get the complete current state.
|
void |
EquationsMapper.insertEquationData(double[] equationData,
double[] complete)
Insert equation data into a complete state or derivative array.
|
void |
FieldEquationsMapper.insertEquationData(int index,
T[] equationData,
T[] complete)
Insert equation data into a complete state or derivative array.
|
abstract void |
AbstractIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
double |
FirstOrderIntegrator.integrate(FirstOrderDifferentialEquations equations,
double t0,
double[] y0,
double t,
double[] y)
Integrate the differential equations up to the given time.
|
double |
AbstractIntegrator.integrate(FirstOrderDifferentialEquations equations,
double t0,
double[] y0,
double t,
double[] y)
Integrate the differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
FieldEquationsMapper.mapStateAndDerivative(T t,
T[] y,
T[] yDot)
Map flat arrays to a state and derivative.
|
void |
JacobianMatrices.registerVariationalEquations(ExpandableStatefulODE expandable)
Register the variational equations for the Jacobians matrices to the expandable set.
|
protected void |
AbstractIntegrator.sanityChecks(ExpandableStatefulODE equations,
double t)
Check the integration span.
|
protected void |
AbstractFieldIntegrator.sanityChecks(FieldODEState<T> eqn,
T t)
Check the integration span.
|
void |
ExpandableStatefulODE.setCompleteState(double[] completeState)
Set the complete current state.
|
void |
JacobianMatrices.setInitialMainStateJacobian(double[][] dYdY0)
Set the initial value of the Jacobian matrix with respect to state.
|
void |
JacobianMatrices.setInitialParameterJacobian(String pName,
double[] dYdP)
Set the initial value of a column of the Jacobian matrix with respect to one parameter.
|
void |
ExpandableStatefulODE.setPrimaryState(double[] primaryState)
Set primary part of the current state.
|
void |
ExpandableStatefulODE.setSecondaryState(int index,
double[] secondaryState)
Set secondary part of the current state.
|
protected void |
MultistepIntegrator.start(double t0,
double[] y0,
double t)
Start the integration.
|
protected void |
MultistepFieldIntegrator.start(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T t)
Start the integration.
|
| Constructor and Description |
|---|
JacobianMatrices(FirstOrderDifferentialEquations fode,
double[] hY,
String... parameters)
Simple constructor for a secondary equations set computing Jacobian matrices.
|
| Modifier and Type | Method and Description |
|---|---|
double |
AdaptiveStepsizeIntegrator.initializeStep(boolean forward,
int order,
double[] scale,
double t0,
double[] y0,
double[] yDot0,
double[] y1,
double[] yDot1)
Initialize the integration step.
|
T |
AdaptiveStepsizeFieldIntegrator.initializeStep(boolean forward,
int order,
T[] scale,
FieldODEStateAndDerivative<T> state0,
FieldEquationsMapper<T> mapper)
Initialize the integration step.
|
abstract void |
AdamsIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
abstract void |
AdaptiveStepsizeIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
void |
AdamsMoultonIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
void |
EmbeddedRungeKuttaIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
void |
AdamsBashforthIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
void |
RungeKuttaIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
void |
GraggBulirschStoerIntegrator.integrate(ExpandableStatefulODE equations,
double t)
Integrate a set of differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
RungeKuttaFieldIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
EmbeddedRungeKuttaFieldIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
AdamsBashforthFieldIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
AdamsMoultonFieldIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
abstract FieldODEStateAndDerivative<T> |
AdamsFieldIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
protected void |
AdaptiveStepsizeIntegrator.sanityChecks(ExpandableStatefulODE equations,
double t)
Check the integration span.
|
protected void |
AdaptiveStepsizeFieldIntegrator.sanityChecks(FieldODEState<T> eqn,
T t)
Check the integration span.
|
| Modifier and Type | Method and Description |
|---|---|
PointValuePair |
CMAESOptimizer.optimize(OptimizationData... optData)
Stores data and performs the optimization.
|
| Modifier and Type | Method and Description |
|---|---|
PointVectorValuePair |
MultivariateVectorOptimizer.optimize(OptimizationData... optData)
Deprecated.
Stores data and performs the optimization.
|
PointVectorValuePair |
JacobianMultivariateVectorOptimizer.optimize(OptimizationData... optData)
Deprecated.
Stores data and performs the optimization.
|
| Modifier and Type | Method and Description |
|---|---|
protected PointVectorValuePair |
BaseAbstractMultivariateVectorOptimizer.optimize(int maxEval,
FUNC f,
OptimizationData... optData)
Deprecated.
Optimize an objective function.
|
protected PointVectorValuePair |
BaseAbstractMultivariateVectorOptimizer.optimizeInternal(int maxEval,
FUNC f,
OptimizationData... optData)
Deprecated.
Optimize an objective function.
|
| Constructor and Description |
|---|
HaltonSequenceGenerator(int dimension,
int[] bases,
int[] weights)
Construct a new Halton sequence generator with the given base numbers and weights for each dimension.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
StatUtils.meanDifference(double[] sample1,
double[] sample2)
Returns the mean of the (signed) differences between corresponding elements of the
input arrays -- i.e., sum(sample1[i] - sample2[i]) / sample1.length.
|
static double |
StatUtils.sumDifference(double[] sample1,
double[] sample2)
Returns the sum of the (signed) differences between corresponding elements of the
input arrays -- i.e., sum(sample1[i] - sample2[i]).
|
static double |
StatUtils.varianceDifference(double[] sample1,
double[] sample2,
double meanDifference)
Returns the variance of the (signed) differences between corresponding elements of the
input arrays -- i.e., var(sample1[i] - sample2[i]).
|
| Modifier and Type | Method and Description |
|---|---|
void |
StorelessCovariance.append(StorelessCovariance sc)
Appends
sc to this, effectively aggregating the computations in sc
with this. |
double |
KendallsCorrelation.correlation(double[] xArray,
double[] yArray)
Computes the Kendall's Tau rank correlation coefficient between the two arrays.
|
void |
StorelessCovariance.increment(double[] data)
Increment the covariance matrix with one row of data.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MultivariateSummaryStatistics.addValue(double[] value)
Add an n-tuple to the data
|
void |
SynchronizedMultivariateSummaryStatistics.addValue(double[] value)
Add an n-tuple to the data
|
void |
MultivariateSummaryStatistics.setGeoMeanImpl(StorelessUnivariateStatistic[] geoMeanImpl)
Sets the implementation for the geometric mean.
|
void |
SynchronizedMultivariateSummaryStatistics.setGeoMeanImpl(StorelessUnivariateStatistic[] geoMeanImpl)
Sets the implementation for the geometric mean.
|
void |
MultivariateSummaryStatistics.setMaxImpl(StorelessUnivariateStatistic[] maxImpl)
Sets the implementation for the maximum.
|
void |
SynchronizedMultivariateSummaryStatistics.setMaxImpl(StorelessUnivariateStatistic[] maxImpl)
Sets the implementation for the maximum.
|
void |
MultivariateSummaryStatistics.setMeanImpl(StorelessUnivariateStatistic[] meanImpl)
Sets the implementation for the mean.
|
void |
SynchronizedMultivariateSummaryStatistics.setMeanImpl(StorelessUnivariateStatistic[] meanImpl)
Sets the implementation for the mean.
|
void |
MultivariateSummaryStatistics.setMinImpl(StorelessUnivariateStatistic[] minImpl)
Sets the implementation for the minimum.
|
void |
SynchronizedMultivariateSummaryStatistics.setMinImpl(StorelessUnivariateStatistic[] minImpl)
Sets the implementation for the minimum.
|
void |
MultivariateSummaryStatistics.setSumImpl(StorelessUnivariateStatistic[] sumImpl)
Sets the implementation for the Sum.
|
void |
SynchronizedMultivariateSummaryStatistics.setSumImpl(StorelessUnivariateStatistic[] sumImpl)
Sets the implementation for the Sum.
|
void |
MultivariateSummaryStatistics.setSumLogImpl(StorelessUnivariateStatistic[] sumLogImpl)
Sets the implementation for the sum of logs.
|
void |
SynchronizedMultivariateSummaryStatistics.setSumLogImpl(StorelessUnivariateStatistic[] sumLogImpl)
Sets the implementation for the sum of logs.
|
void |
MultivariateSummaryStatistics.setSumsqImpl(StorelessUnivariateStatistic[] sumsqImpl)
Sets the implementation for the sum of squares.
|
void |
SynchronizedMultivariateSummaryStatistics.setSumsqImpl(StorelessUnivariateStatistic[] sumsqImpl)
Sets the implementation for the sum of squares.
|
| Modifier and Type | Method and Description |
|---|---|
void |
VectorialMean.increment(double[] v)
Add a new vector to the sample.
|
void |
VectorialCovariance.increment(double[] v)
Add a new vector to the sample.
|
| Modifier and Type | Method and Description |
|---|---|
double |
OneWayAnova.anovaFValue(Collection<double[]> categoryData)
Computes the ANOVA F-value for a collection of
double[]
arrays. |
double |
OneWayAnova.anovaPValue(Collection<double[]> categoryData)
Computes the ANOVA P-value for a collection of
double[]
arrays. |
double |
OneWayAnova.anovaPValue(Collection<SummaryStatistics> categoryData,
boolean allowOneElementData)
Computes the ANOVA P-value for a collection of
SummaryStatistics. |
boolean |
OneWayAnova.anovaTest(Collection<double[]> categoryData,
double alpha)
Performs an ANOVA test, evaluating the null hypothesis that there
is no difference among the means of the data categories.
|
static double |
TestUtils.chiSquare(double[] expected,
long[] observed) |
double |
ChiSquareTest.chiSquare(double[] expected,
long[] observed)
|
static double |
TestUtils.chiSquare(long[][] counts) |
double |
ChiSquareTest.chiSquare(long[][] counts)
Computes the Chi-Square statistic associated with a
chi-square test of independence based on the input
counts
array, viewed as a two-way table. |
static double |
TestUtils.chiSquareDataSetsComparison(long[] observed1,
long[] observed2) |
double |
ChiSquareTest.chiSquareDataSetsComparison(long[] observed1,
long[] observed2)
Computes a
Chi-Square two sample test statistic comparing bin frequency counts
in
observed1 and observed2. |
static double |
TestUtils.chiSquareTest(double[] expected,
long[] observed) |
double |
ChiSquareTest.chiSquareTest(double[] expected,
long[] observed)
Returns the observed significance level, or
p-value, associated with a
Chi-square goodness of fit test comparing the
observed
frequency counts to those in the expected array. |
static boolean |
TestUtils.chiSquareTest(double[] expected,
long[] observed,
double alpha) |
boolean |
ChiSquareTest.chiSquareTest(double[] expected,
long[] observed,
double alpha)
Performs a
Chi-square goodness of fit test evaluating the null hypothesis that the
observed counts conform to the frequency distribution described by the expected
counts, with significance level
alpha. |
static double |
TestUtils.chiSquareTest(long[][] counts) |
double |
ChiSquareTest.chiSquareTest(long[][] counts)
Returns the observed significance level, or
p-value, associated with a
chi-square test of independence based on the input
counts
array, viewed as a two-way table. |
static boolean |
TestUtils.chiSquareTest(long[][] counts,
double alpha) |
boolean |
ChiSquareTest.chiSquareTest(long[][] counts,
double alpha)
Performs a
chi-square test of independence evaluating the null hypothesis that the
classifications represented by the counts in the columns of the input 2-way table
are independent of the rows, with significance level
alpha. |
static double |
TestUtils.chiSquareTestDataSetsComparison(long[] observed1,
long[] observed2) |
double |
ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1,
long[] observed2)
Returns the observed significance level, or
p-value, associated with a Chi-Square two sample test comparing
bin frequency counts in
observed1 and
observed2. |
static boolean |
TestUtils.chiSquareTestDataSetsComparison(long[] observed1,
long[] observed2,
double alpha) |
boolean |
ChiSquareTest.chiSquareTestDataSetsComparison(long[] observed1,
long[] observed2,
double alpha)
Performs a Chi-Square two sample test comparing two binned data
sets.
|
static double |
TestUtils.g(double[] expected,
long[] observed) |
double |
GTest.g(double[] expected,
long[] observed)
|
static double |
TestUtils.gDataSetsComparison(long[] observed1,
long[] observed2) |
double |
GTest.gDataSetsComparison(long[] observed1,
long[] observed2)
Computes a G (Log-Likelihood Ratio) two sample test statistic for
independence comparing frequency counts in
observed1 and observed2. |
static double |
TestUtils.gTest(double[] expected,
long[] observed) |
double |
GTest.gTest(double[] expected,
long[] observed)
Returns the observed significance level, or p-value,
associated with a G-Test for goodness of fit comparing the
observed frequency counts to those in the expected array. |
static boolean |
TestUtils.gTest(double[] expected,
long[] observed,
double alpha) |
boolean |
GTest.gTest(double[] expected,
long[] observed,
double alpha)
Performs a G-Test (Log-Likelihood Ratio Test) for goodness of fit
evaluating the null hypothesis that the observed counts conform to the
frequency distribution described by the expected counts, with
significance level
alpha. |
static double |
TestUtils.gTestDataSetsComparison(long[] observed1,
long[] observed2) |
double |
GTest.gTestDataSetsComparison(long[] observed1,
long[] observed2)
Returns the observed significance level, or
p-value, associated with a G-Value (Log-Likelihood Ratio) for two
sample test comparing bin frequency counts in
observed1 and
observed2. |
static boolean |
TestUtils.gTestDataSetsComparison(long[] observed1,
long[] observed2,
double alpha) |
boolean |
GTest.gTestDataSetsComparison(long[] observed1,
long[] observed2,
double alpha)
Performs a G-Test (Log-Likelihood Ratio Test) comparing two binned
data sets.
|
static double |
TestUtils.gTestIntrinsic(double[] expected,
long[] observed) |
double |
GTest.gTestIntrinsic(double[] expected,
long[] observed)
Returns the intrinsic (Hardy-Weinberg proportions) p-Value, as described
in p64-69 of McDonald, J.H.
|
static double |
TestUtils.oneWayAnovaFValue(Collection<double[]> categoryData) |
static double |
TestUtils.oneWayAnovaPValue(Collection<double[]> categoryData) |
static boolean |
TestUtils.oneWayAnovaTest(Collection<double[]> categoryData,
double alpha) |
static double |
TestUtils.pairedT(double[] sample1,
double[] sample2) |
double |
TTest.pairedT(double[] sample1,
double[] sample2)
Computes a paired, 2-sample t-statistic based on the data in the input
arrays.
|
static double |
TestUtils.pairedTTest(double[] sample1,
double[] sample2) |
double |
TTest.pairedTTest(double[] sample1,
double[] sample2)
Returns the observed significance level, or
p-value, associated with a paired, two-sample, two-tailed t-test
based on the data in the input arrays.
|
static boolean |
TestUtils.pairedTTest(double[] sample1,
double[] sample2,
double alpha) |
boolean |
TTest.pairedTTest(double[] sample1,
double[] sample2,
double alpha)
Performs a paired t-test evaluating the null hypothesis that the
mean of the paired differences between
sample1 and
sample2 is 0 in favor of the two-sided alternative that the
mean paired difference is not equal to 0, with significance level
alpha. |
static double |
TestUtils.rootLogLikelihoodRatio(long k11,
long k12,
long k21,
long k22) |
double |
WilcoxonSignedRankTest.wilcoxonSignedRank(double[] x,
double[] y)
Computes the
Wilcoxon signed ranked statistic comparing mean for two related
samples or repeated measurements on a single sample.
|
double |
WilcoxonSignedRankTest.wilcoxonSignedRankTest(double[] x,
double[] y,
boolean exactPValue)
Returns the observed significance level, or
p-value, associated with a
Wilcoxon signed ranked statistic comparing mean for two related
samples or repeated measurements on a single sample.
|
| Modifier and Type | Method and Description |
|---|---|
static Complex[] |
TransformUtils.createComplexArray(double[][] dataRI)
Builds a new array of
Complex from the specified two dimensional
array of real and imaginary parts. |
| Modifier and Type | Method and Description |
|---|---|
static void |
MathArrays.checkRectangular(long[][] in)
Throws DimensionMismatchException if the input array is not rectangular.
|
static double |
MathArrays.distance(double[] p1,
double[] p2)
Calculates the L2 (Euclidean) distance between two points.
|
static double |
MathArrays.distance(int[] p1,
int[] p2)
Calculates the L2 (Euclidean) distance between two points.
|
static double |
MathArrays.distance1(double[] p1,
double[] p2)
Calculates the L1 (sum of abs) distance between two points.
|
static int |
MathArrays.distance1(int[] p1,
int[] p2)
Calculates the L1 (sum of abs) distance between two points.
|
static double |
MathArrays.distanceInf(double[] p1,
double[] p2)
Calculates the L∞ (max of abs) distance between two points.
|
static int |
MathArrays.distanceInf(int[] p1,
int[] p2)
Calculates the L∞ (max of abs) distance between two points.
|
static double[] |
MathArrays.ebeAdd(double[] a,
double[] b)
Creates an array whose contents will be the element-by-element
addition of the arguments.
|
static double[] |
MathArrays.ebeDivide(double[] a,
double[] b)
Creates an array whose contents will be the element-by-element
division of the first argument by the second.
|
static double[] |
MathArrays.ebeMultiply(double[] a,
double[] b)
Creates an array whose contents will be the element-by-element
multiplication of the arguments.
|
static double[] |
MathArrays.ebeSubtract(double[] a,
double[] b)
Creates an array whose contents will be the element-by-element
subtraction of the second argument from the first.
|
int |
MultidimensionalCounter.getCount(int... c)
Convert to unidimensional counter.
|
Decimal64 |
Decimal64.linearCombination(Decimal64[] a,
Decimal64[] b)
Compute a linear combination.
|
Decimal64 |
Decimal64.linearCombination(double[] a,
Decimal64[] b)
Compute a linear combination.
|
static double |
MathArrays.linearCombination(double[] a,
double[] b)
Compute a linear combination accurately.
|
static void |
MathArrays.sortInPlace(double[] x,
double[]... yList)
Sort an array in ascending order in place and perform the same reordering
of entries on other arrays.
|
static void |
MathArrays.sortInPlace(double[] x,
MathArrays.OrderDirection dir,
double[]... yList)
Sort an array in place and perform the same reordering of entries on
other arrays.
|
Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.