| Package | Description |
|---|---|
| org.hipparchus |
Common classes used throughout the Hipparchus library.
|
| org.hipparchus.analysis |
Parent package for common numerical analysis procedures, including root finding,
function interpolation and integration.
|
| org.hipparchus.analysis.differentiation |
This package holds the main interfaces and basic building block classes
dealing with differentiation.
|
| org.hipparchus.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.hipparchus.analysis.integration |
Numerical integration (quadrature) algorithms for univariate real functions.
|
| org.hipparchus.analysis.integration.gauss |
Gauss family of quadrature schemes.
|
| org.hipparchus.analysis.interpolation |
Univariate real functions interpolation algorithms.
|
| org.hipparchus.analysis.polynomials |
Univariate real polynomials implementations, seen as differentiable
univariate real functions.
|
| org.hipparchus.analysis.solvers |
Root finding algorithms, for univariate real functions.
|
| org.hipparchus.clustering |
Clustering algorithms.
|
| org.hipparchus.clustering.distance |
Common distance measures.
|
| org.hipparchus.complex |
Complex number type and implementations of complex transcendental
functions.
|
| org.hipparchus.dfp |
Decimal floating point library for Java
|
| org.hipparchus.distribution |
Interfaces and implementations of common discrete and
continuous distributions.
|
| org.hipparchus.distribution.continuous |
Implementations of common continuous distributions.
|
| org.hipparchus.distribution.discrete |
Implementations of common discrete distributions.
|
| org.hipparchus.distribution.multivariate |
Implementations of multivariate distributions.
|
| org.hipparchus.fraction |
Fraction number type and fraction number formatting.
|
| org.hipparchus.geometry.euclidean.threed |
This package provides basic 3D geometry components.
|
| org.hipparchus.geometry.euclidean.twod |
This package provides basic 2D geometry components.
|
| org.hipparchus.geometry.euclidean.twod.hull |
This package provides algorithms to generate the convex hull
for a set of points in an two-dimensional euclidean space.
|
| org.hipparchus.geometry.hull |
This package provides interfaces and classes related to the convex hull problem.
|
| org.hipparchus.geometry.spherical.oned |
This package provides basic geometry components on the 1-sphere.
|
| org.hipparchus.geometry.spherical.twod |
This package provides basic geometry components on the 2-sphere.
|
| org.hipparchus.linear |
Linear algebra support.
|
| org.hipparchus.migration.exception |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.migration.genetics |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.migration.geometry.euclidean.threed |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.migration.linear |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.migration.ode |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.migration.stat.regression |
This package provides migration classes from Apache Commons Math to Hipparchus.
|
| org.hipparchus.ode |
This package provides classes to solve Ordinary Differential Equations problems.
|
| org.hipparchus.ode.events |
Events
|
| org.hipparchus.ode.nonstiff |
This package provides classes to solve non-stiff Ordinary Differential Equations problems.
|
| org.hipparchus.optim.nonlinear.scalar |
Algorithms for optimizing a scalar function.
|
| org.hipparchus.optim.nonlinear.scalar.noderiv |
This package provides optimization algorithms that do not require derivatives.
|
| org.hipparchus.random |
Random number and random data generators.
|
| org.hipparchus.special |
Implementations of special functions such as Beta and Gamma.
|
| org.hipparchus.stat |
Data storage, manipulation and summary routines.
|
| org.hipparchus.stat.correlation |
Correlations/Covariance computations.
|
| org.hipparchus.stat.descriptive |
Generic univariate and multivariate summary statistic objects.
|
| org.hipparchus.stat.descriptive.moment |
Summary statistics based on moments.
|
| org.hipparchus.stat.descriptive.rank |
Summary statistics based on ranks.
|
| org.hipparchus.stat.descriptive.summary |
Other summary statistics.
|
| org.hipparchus.stat.descriptive.vector |
Multivariate statistics.
|
| org.hipparchus.stat.fitting |
Statistical methods for fitting distributions.
|
| org.hipparchus.stat.inference |
Classes providing hypothesis testing.
|
| org.hipparchus.stat.interval |
Utilities to calculate binomial proportion confidence intervals.
|
| org.hipparchus.stat.regression |
Statistical routines involving multivariate data.
|
| org.hipparchus.transform |
Implementations of transform methods, including Fast Fourier transforms.
|
| org.hipparchus.util |
Convenience routines and common data structures used throughout the Hipparchus 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 |
|---|---|
static double[] |
FunctionUtils.sample(UnivariateFunction f,
double min,
double max,
int n)
Samples the specified univariate real function on the specified interval.
|
| Modifier and Type | Method and Description |
|---|---|
DerivativeStructure |
DerivativeStructure.add(DerivativeStructure a)
Compute this + a.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.add(FieldDerivativeStructure<T> 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.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.atan2(FieldDerivativeStructure<T> x)
Two arguments arc tangent operation.
|
static <T extends RealFieldElement<T>> |
FieldDerivativeStructure.atan2(FieldDerivativeStructure<T> y,
FieldDerivativeStructure<T> x)
Two arguments arc tangent operation.
|
FieldDerivativeStructure<T> |
FDSFactory.build(double... derivatives)
Build a
FieldDerivativeStructure from all its derivatives. |
DerivativeStructure |
DSFactory.build(double... derivatives)
Build a
DerivativeStructure from all its derivatives. |
FieldDerivativeStructure<T> |
FDSFactory.build(T... derivatives)
Build a
FieldDerivativeStructure from all its derivatives. |
void |
DSCompiler.checkCompatibility(DSCompiler compiler)
Check rules set compatibility.
|
DerivativeStructure |
DerivativeStructure.compose(double... f)
Compute composition of the instance by a univariate function.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.compose(double... f)
Compute composition of the instance by a univariate function.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.compose(T... f)
Compute composition of the instance by a univariate function.
|
DerivativeStructure |
DerivativeStructure.divide(DerivativeStructure a)
Compute this ÷ a.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.divide(FieldDerivativeStructure<T> a)
Compute this ÷ a.
|
static DSCompiler |
DSCompiler.getCompiler(int parameters,
int order)
Get the compiler for number of free parameters and order.
|
double |
DerivativeStructure.getPartialDerivative(int... orders)
Get a partial derivative.
|
T |
FieldDerivativeStructure.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. |
FieldDerivativeStructure<T> |
FieldDerivativeStructure.hypot(FieldDerivativeStructure<T> y)
Returns the hypotenuse of a triangle with sides
this and y
- sqrt(this2 +y2)
avoiding intermediate overflow or underflow. |
static <T extends RealFieldElement<T>> |
FieldDerivativeStructure.hypot(FieldDerivativeStructure<T> x,
FieldDerivativeStructure<T> 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.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(double[] a,
FieldDerivativeStructure<T>[] 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.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(double a1,
FieldDerivativeStructure<T> b1,
double a2,
FieldDerivativeStructure<T> b2)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(double a1,
FieldDerivativeStructure<T> b1,
double a2,
FieldDerivativeStructure<T> b2,
double a3,
FieldDerivativeStructure<T> b3)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(double a1,
FieldDerivativeStructure<T> b1,
double a2,
FieldDerivativeStructure<T> b2,
double a3,
FieldDerivativeStructure<T> b3,
double a4,
FieldDerivativeStructure<T> b4)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(FieldDerivativeStructure<T>[] a,
FieldDerivativeStructure<T>[] b)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(FieldDerivativeStructure<T> a1,
FieldDerivativeStructure<T> b1,
FieldDerivativeStructure<T> a2,
FieldDerivativeStructure<T> b2)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(FieldDerivativeStructure<T> a1,
FieldDerivativeStructure<T> b1,
FieldDerivativeStructure<T> a2,
FieldDerivativeStructure<T> b2,
FieldDerivativeStructure<T> a3,
FieldDerivativeStructure<T> b3)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(FieldDerivativeStructure<T> a1,
FieldDerivativeStructure<T> b1,
FieldDerivativeStructure<T> a2,
FieldDerivativeStructure<T> b2,
FieldDerivativeStructure<T> a3,
FieldDerivativeStructure<T> b3,
FieldDerivativeStructure<T> a4,
FieldDerivativeStructure<T> b4)
Compute a linear combination.
|
SparseGradient |
SparseGradient.linearCombination(SparseGradient[] a,
SparseGradient[] b)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(T[] a,
FieldDerivativeStructure<T>[] b)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(T a1,
FieldDerivativeStructure<T> b1,
T a2,
FieldDerivativeStructure<T> b2)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(T a1,
FieldDerivativeStructure<T> b1,
T a2,
FieldDerivativeStructure<T> b2,
T a3,
FieldDerivativeStructure<T> b3)
Compute a linear combination.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.linearCombination(T a1,
FieldDerivativeStructure<T> b1,
T a2,
FieldDerivativeStructure<T> b2,
T a3,
FieldDerivativeStructure<T> b3,
T a4,
FieldDerivativeStructure<T> b4)
Compute a linear combination.
|
DerivativeStructure |
DerivativeStructure.multiply(DerivativeStructure a)
Compute this × a.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.multiply(FieldDerivativeStructure<T> a)
Compute this × a.
|
DerivativeStructure |
DerivativeStructure.pow(DerivativeStructure e)
Power operation.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.pow(FieldDerivativeStructure<T> e)
Power operation.
|
DerivativeStructure |
DerivativeStructure.remainder(DerivativeStructure a)
IEEE remainder operator.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.remainder(FieldDerivativeStructure<T> a)
IEEE remainder operator.
|
DerivativeStructure |
DerivativeStructure.subtract(DerivativeStructure a)
Compute this - a.
|
FieldDerivativeStructure<T> |
FieldDerivativeStructure.subtract(FieldDerivativeStructure<T> a)
Compute this - a.
|
DerivativeStructure |
UnivariateDifferentiableFunction.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure[] |
UnivariateDifferentiableVectorFunction.value(DerivativeStructure x)
Compute the value for the function.
|
DerivativeStructure[][] |
UnivariateDifferentiableMatrixFunction.value(DerivativeStructure x)
Compute the value for the function.
|
DerivativeStructure |
MultivariateDifferentiableFunction.value(DerivativeStructure[] point)
Compute the value for the function at the given point.
|
DerivativeStructure[] |
MultivariateDifferentiableVectorFunction.value(DerivativeStructure[] point)
Compute the value for the function at the given point.
|
FieldDerivativeStructure<T> |
FDSFactory.variable(int index,
double value)
Build a
FieldDerivativeStructure representing a variable. |
DerivativeStructure |
DSFactory.variable(int index,
double value)
Build a
DerivativeStructure representing a variable. |
FieldDerivativeStructure<T> |
FDSFactory.variable(int index,
T value)
Build a
FieldDerivativeStructure representing a variable. |
| Constructor and Description |
|---|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2)
Deprecated.
|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2,
double a3,
DerivativeStructure ds3)
Deprecated.
|
DerivativeStructure(double a1,
DerivativeStructure ds1,
double a2,
DerivativeStructure ds2,
double a3,
DerivativeStructure ds3,
double a4,
DerivativeStructure ds4)
|
DerivativeStructure(int parameters,
int order)
Deprecated.
as of 1.1, replaced by
DSFactory.build() |
DerivativeStructure(int parameters,
int order,
double... derivatives)
Deprecated.
as of 1.1, replaced by
DSFactory.build(double...) |
DerivativeStructure(int parameters,
int order,
double value)
Deprecated.
as of 1.1, replaced by
DSFactory.constant(double) |
DerivativeStructure(int parameters,
int order,
int index,
double value)
Deprecated.
as of 1.1, replaced by
DSFactory.variable(int, double) |
FiniteDifferencesDifferentiator(int nbPoints,
double stepSize)
Build a differentiator with number of points and step size when independent variable is unbounded.
|
FiniteDifferencesDifferentiator(int nbPoints,
double stepSize,
double tLower,
double tUpper)
Build a differentiator with number of points and step size when independent variable is bounded.
|
| Modifier and Type | Method and Description |
|---|---|
double[] |
HarmonicOscillator.Parametric.gradient(double x,
double... param)
Computes the value of the gradient at
x. |
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[] |
Gaussian.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. |
DerivativeStructure |
HarmonicOscillator.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Logit.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Sinc.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Gaussian.value(DerivativeStructure t)
Simple mathematical function.
|
DerivativeStructure |
Sigmoid.value(DerivativeStructure t)
Simple mathematical function.
|
double |
Logit.value(double x)
Compute the value of the function.
|
double |
HarmonicOscillator.Parametric.value(double x,
double... param)
Computes the value of the harmonic oscillator at
x. |
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 |
Gaussian.Parametric.value(double x,
double... param)
Computes the value of the Gaussian at
x. |
double |
Sigmoid.Parametric.value(double x,
double... param)
Computes the value of the sigmoid at
x. |
| Constructor and Description |
|---|
Gaussian(double mean,
double sigma)
Normalized gaussian with given mean and standard deviation.
|
Gaussian(double norm,
double mean,
double sigma)
Gaussian with given normalization factor, mean and standard deviation.
|
Logistic(double k,
double m,
double b,
double q,
double a,
double n) |
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 double |
IterativeLegendreGaussIntegrator.doIntegrate()
Method for implementing actual integration algorithms in derived
classes.
|
protected double |
MidPointIntegrator.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.
|
| Constructor and Description |
|---|
BaseAbstractUnivariateIntegrator(double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Construct an integrator with given accuracies and iteration counts.
|
BaseAbstractUnivariateIntegrator(int minimalIterationCount,
int maximalIterationCount)
Construct an integrator with given iteration counts.
|
IterativeLegendreGaussIntegrator(int n,
double relativeAccuracy,
double absoluteAccuracy)
Builds an integrator with given accuracies.
|
IterativeLegendreGaussIntegrator(int n,
double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Builds an integrator with given accuracies and iterations counts.
|
IterativeLegendreGaussIntegrator(int n,
int minimalIterationCount,
int maximalIterationCount)
Builds an integrator with given iteration counts.
|
MidPointIntegrator(double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Build a midpoint integrator with given accuracies and iterations counts.
|
MidPointIntegrator(int minimalIterationCount,
int maximalIterationCount)
Build a midpoint integrator with given iteration counts.
|
RombergIntegrator(double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Build a Romberg integrator with given accuracies and iterations counts.
|
RombergIntegrator(int minimalIterationCount,
int maximalIterationCount)
Build a Romberg integrator with given iteration counts.
|
SimpsonIntegrator(double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Build a Simpson integrator with given accuracies and iterations counts.
|
SimpsonIntegrator(int minimalIterationCount,
int maximalIterationCount)
Build a Simpson integrator with given iteration counts.
|
TrapezoidIntegrator(double relativeAccuracy,
double absoluteAccuracy,
int minimalIterationCount,
int maximalIterationCount)
Build a trapezoid integrator with given accuracies and iterations counts.
|
TrapezoidIntegrator(int minimalIterationCount,
int maximalIterationCount)
Build a trapezoid integrator with given iteration counts.
|
| 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 abstract Pair<T[],T[]> |
BaseRuleFactory.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 Pair<Double[],Double[]> |
LegendreRuleFactory.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.
|
GaussIntegrator |
GaussIntegratorFactory.legendre(int numberOfPoints,
double lowerBound,
double upperBound)
Creates a Gauss-Legendre integrator of the given order.
|
GaussIntegrator |
GaussIntegratorFactory.legendreHighPrecision(int numberOfPoints)
Creates a Gauss-Legendre integrator of the given order.
|
GaussIntegrator |
GaussIntegratorFactory.legendreHighPrecision(int numberOfPoints,
double lowerBound,
double upperBound)
Creates an integrator of the given order, and whose call to the
integrate method will perform an integration on the given interval. |
| Constructor and Description |
|---|
GaussIntegrator(double[] points,
double[] weights)
Creates an integrator from the given
points and weights. |
GaussIntegrator(Pair<double[],double[]> pointsAndWeights)
Creates an integrator from the given pair of points (first element of
the pair) and weights (second element of the pair.
|
SymmetricGaussIntegrator(double[] points,
double[] weights)
Creates an integrator from the given
points and weights. |
SymmetricGaussIntegrator(Pair<double[],double[]> pointsAndWeights)
Creates an integrator from the given pair of points (first element of
the pair) and weights (second element of the pair.
|
| Modifier and Type | Method and Description |
|---|---|
void |
HermiteInterpolator.addSamplePoint(double x,
double[]... value)
Add a sample point.
|
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.
|
double[][] |
HermiteInterpolator.derivatives(double x,
int order)
Interpolate value and first derivatives at a specified abscissa.
|
T[][] |
FieldHermiteInterpolator.derivatives(T x,
int order)
Interpolate value and first derivatives at a specified abscissa.
|
PolynomialFunction[] |
HermiteInterpolator.getPolynomials()
Compute the interpolation polynomials.
|
MultivariateFunction |
MultivariateInterpolator.interpolate(double[][] xval,
double[] yval)
Computes an interpolating function for the data set.
|
MultivariateFunction |
MicrosphereProjectionInterpolator.interpolate(double[][] xval,
double[] yval)
Computes an interpolating function for the data set.
|
UnivariateFunction |
UnivariatePeriodicInterpolator.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 |
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. |
PolynomialSplineFunction |
AkimaSplineInterpolator.interpolate(double[] xvals,
double[] yvals)
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.
|
PolynomialFunctionNewtonForm |
DividedDifferenceInterpolator.interpolate(double[] x,
double[] y)
Compute an interpolating function for the dataset.
|
PolynomialSplineFunction |
SplineInterpolator.interpolate(double[] x,
double[] y)
Computes an interpolating function for the data set.
|
BicubicInterpolatingFunction |
BicubicInterpolator.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.
|
PiecewiseBicubicSplineInterpolatingFunction |
PiecewiseBicubicSplineInterpolator.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.
|
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.
|
DerivativeStructure[] |
HermiteInterpolator.value(DerivativeStructure x)
Interpolate value at a specified abscissa.
|
double[] |
HermiteInterpolator.value(double x)
Interpolate value at a specified abscissa.
|
double |
BicubicInterpolatingFunction.value(double x,
double y)
Compute the value for the function.
|
double |
PiecewiseBicubicSplineInterpolatingFunction.value(double x,
double y)
Compute the value for the function.
|
double |
TricubicInterpolatingFunction.value(double x,
double y,
double z)
Compute the value for the function.
|
T[] |
FieldHermiteInterpolator.value(T x)
Interpolate value at a specified abscissa.
|
| Constructor and Description |
|---|
BicubicInterpolatingFunction(double[] x,
double[] y,
double[][] f,
double[][] dFdX,
double[][] dFdY,
double[][] d2FdXdY) |
LoessInterpolator(double bandwidth,
int robustnessIters,
double accuracy)
Construct a new
LoessInterpolator
with given bandwidth, number of robustness iterations and accuracy. |
MicrosphereProjectionInterpolator(InterpolatingMicrosphere microsphere,
double exponent,
boolean sharedSphere,
double noInterpolationTolerance)
Create a microsphere interpolator.
|
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) |
| Modifier and Type | Method and Description |
|---|---|
protected static double[] |
PolynomialFunction.differentiate(double[] coefficients)
Returns the coefficients of the derivative of the polynomial with the given coefficients.
|
protected static double |
PolynomialFunction.evaluate(double[] coefficients,
double argument)
Uses Horner's Method to evaluate the polynomial with the given coefficients at
the argument.
|
static double |
PolynomialFunctionNewtonForm.evaluate(double[] a,
double[] c,
double z)
Evaluate the Newton polynomial using nested multiplication.
|
static double |
PolynomialFunctionLagrangeForm.evaluate(double[] x,
double[] y,
double z)
Evaluate the Lagrange polynomial using
Neville's Algorithm.
|
DerivativeStructure |
PolynomialFunction.value(DerivativeStructure t)
Simple mathematical function.
|
double |
PolynomialFunction.Parametric.value(double x,
double... parameters)
Compute the value of the function.
|
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 |
|---|
PolynomialFunction(double[] c)
Construct a polynomial with the given coefficients.
|
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.
|
| Modifier and Type | Method and Description |
|---|---|
static <T extends RealFieldElement<T>> |
UnivariateSolverUtils.bracket(RealFieldUnivariateFunction<T> function,
T initial,
T lowerBound,
T upperBound)
This method simply calls
bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)
with q and r set to 1.0 and maximumIterations set to Integer.MAX_VALUE. |
static <T extends RealFieldElement<T>> |
UnivariateSolverUtils.bracket(RealFieldUnivariateFunction<T> function,
T initial,
T lowerBound,
T upperBound,
int maximumIterations)
This method simply calls
bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)
with q and r set to 1.0. |
static <T extends RealFieldElement<T>> |
UnivariateSolverUtils.bracket(RealFieldUnivariateFunction<T> function,
T initial,
T lowerBound,
T upperBound,
T q,
T r,
int maximumIterations)
This method attempts to find two values a and b satisfying
lowerBound <= a < initial < b <= upperBound
f(a) * f(b) <= 0
If f is continuous on [a,b], this means that a
and b bracket a root of f. |
static double[] |
UnivariateSolverUtils.bracket(UnivariateFunction function,
double initial,
double lowerBound,
double upperBound)
This method simply calls
bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)
with q and r set to 1.0 and maximumIterations set to Integer.MAX_VALUE. |
static double[] |
UnivariateSolverUtils.bracket(UnivariateFunction function,
double initial,
double lowerBound,
double upperBound,
double q,
double r,
int maximumIterations)
This method attempts to find two values a and b satisfying
lowerBound <= a < initial < b <= upperBound
f(a) * f(b) <= 0
If f is continuous on [a,b], this means that a
and b bracket a root of f. |
static double[] |
UnivariateSolverUtils.bracket(UnivariateFunction function,
double initial,
double lowerBound,
double upperBound,
int maximumIterations)
This method simply calls
bracket(function, initial, lowerBound, upperBound, q, r, maximumIterations)
with q and r set to 1.0. |
protected double |
MullerSolver2.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
double |
LaguerreSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
protected double |
MullerSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
protected double |
BrentSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
protected abstract double |
BaseAbstractUnivariateSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
protected double |
SecantSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
protected double |
RiddersSolver.doSolve()
Method for implementing actual optimization algorithms in derived
classes.
|
static double |
UnivariateSolverUtils.forceSide(int maxEval,
UnivariateFunction f,
BracketedUnivariateSolver<UnivariateFunction> bracketing,
double baseRoot,
double min,
double max,
AllowedSolution allowedSolution)
Force a root found by a non-bracketing solver to lie on a specified side,
as if the solver were a bracketing one.
|
double |
BaseAbstractUnivariateSolver.solve(int maxEval,
FUNC f,
double startValue)
Solve for a zero in the vicinity of
startValue. |
double |
BaseUnivariateSolver.solve(int maxEval,
FUNC f,
double min,
double max)
Solve for a zero root in the given interval.
|
double |
BaseAbstractUnivariateSolver.solve(int maxEval,
FUNC f,
double min,
double max,
double startValue)
Solve for a zero in the given interval, start at
startValue. |
double |
BaseUnivariateSolver.solve(int maxEval,
FUNC f,
double min,
double max,
double startValue)
Solve for a zero in the given interval, start at
startValue. |
T |
FieldBracketingNthOrderBrentSolver.solve(int maxEval,
RealFieldUnivariateFunction<T> f,
T min,
T max,
AllowedSolution allowedSolution)
Solve for a zero in the given interval.
|
T |
FieldBracketingNthOrderBrentSolver.solve(int maxEval,
RealFieldUnivariateFunction<T> f,
T min,
T max,
T startValue,
AllowedSolution allowedSolution)
Solve for a zero in the given interval, start at
startValue. |
double |
BracketingNthOrderBrentSolver.solve(int maxEval,
UnivariateFunction f,
double min,
double max,
AllowedSolution allowedSolution)
Solve for a zero in the given interval.
|
double |
BracketingNthOrderBrentSolver.solve(int maxEval,
UnivariateFunction f,
double min,
double max,
double startValue,
AllowedSolution allowedSolution)
Solve for a zero in the given interval, start at
startValue. |
static double |
UnivariateSolverUtils.solve(UnivariateFunction function,
double x0,
double x1)
Convenience method to find a zero of a univariate real function.
|
static double |
UnivariateSolverUtils.solve(UnivariateFunction function,
double x0,
double x1,
double absoluteAccuracy)
Convenience method to find a zero of a univariate real function.
|
Complex[] |
LaguerreSolver.solveAllComplex(double[] coefficients,
double initial)
Find all complex roots for the polynomial with the given
coefficients, starting from the given initial value.
|
Complex |
LaguerreSolver.solveComplex(double[] coefficients,
double initial)
Find a complex root for the polynomial with the given coefficients,
starting from the given initial value.
|
default BracketedUnivariateSolver.Interval |
BracketedUnivariateSolver.solveInterval(int maxEval,
FUNC f,
double min,
double max)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
BracketedUnivariateSolver.Interval |
BracketedUnivariateSolver.solveInterval(int maxEval,
FUNC f,
double min,
double max,
double startValue)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
default BracketedRealFieldUnivariateSolver.Interval<T> |
BracketedRealFieldUnivariateSolver.solveInterval(int maxEval,
RealFieldUnivariateFunction<T> f,
T min,
T max)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
BracketedRealFieldUnivariateSolver.Interval<T> |
BracketedRealFieldUnivariateSolver.solveInterval(int maxEval,
RealFieldUnivariateFunction<T> f,
T min,
T max,
T startValue)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
BracketedRealFieldUnivariateSolver.Interval<T> |
FieldBracketingNthOrderBrentSolver.solveInterval(int maxEval,
RealFieldUnivariateFunction<T> f,
T min,
T max,
T startValue)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
BracketedUnivariateSolver.Interval |
BracketingNthOrderBrentSolver.solveInterval(int maxEval,
UnivariateFunction f,
double min,
double max,
double startValue)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
BracketedUnivariateSolver.Interval |
BaseSecantSolver.solveInterval(int maxEval,
UnivariateFunction f,
double min,
double max,
double startValue)
Solve for a zero in the given interval and return a tolerance interval surrounding
the root.
|
protected void |
BaseAbstractUnivariateSolver.verifyBracketing(double lower,
double upper)
Check that the endpoints specify an interval and the function takes
opposite signs at the endpoints.
|
static void |
UnivariateSolverUtils.verifyBracketing(UnivariateFunction function,
double lower,
double upper)
Check that the endpoints specify an interval and the end points
bracket a root.
|
static void |
UnivariateSolverUtils.verifyInterval(double lower,
double upper)
Check that the endpoints specify an interval.
|
protected void |
BaseAbstractUnivariateSolver.verifyInterval(double lower,
double upper)
Check that the endpoints specify an interval.
|
static void |
UnivariateSolverUtils.verifySequence(double lower,
double initial,
double upper)
Check that
lower < initial < upper. |
protected void |
BaseAbstractUnivariateSolver.verifySequence(double lower,
double initial,
double upper)
Check that
lower < initial < upper. |
| Constructor and Description |
|---|
BracketingNthOrderBrentSolver(double relativeAccuracy,
double absoluteAccuracy,
double functionValueAccuracy,
int maximalOrder)
Construct a solver.
|
BracketingNthOrderBrentSolver(double relativeAccuracy,
double absoluteAccuracy,
int maximalOrder)
Construct a solver.
|
BracketingNthOrderBrentSolver(double absoluteAccuracy,
int maximalOrder)
Construct a solver.
|
FieldBracketingNthOrderBrentSolver(T relativeAccuracy,
T absoluteAccuracy,
T functionValueAccuracy,
int maximalOrder)
Construct a solver.
|
| Modifier and Type | Method and Description |
|---|---|
List<CentroidCluster<T>> |
FuzzyKMeansClusterer.cluster(Collection<T> dataPoints)
Performs Fuzzy K-Means cluster analysis.
|
abstract List<? extends Cluster<T>> |
Clusterer.cluster(Collection<T> points)
Perform a cluster analysis on the given set of
Clusterable instances. |
List<CentroidCluster<T>> |
MultiKMeansPlusPlusClusterer.cluster(Collection<T> points)
Runs the K-means++ clustering algorithm.
|
List<CentroidCluster<T>> |
KMeansPlusPlusClusterer.cluster(Collection<T> points)
Runs the K-means++ clustering algorithm.
|
| Constructor and Description |
|---|
DBSCANClusterer(double eps,
int minPts)
Creates a new instance of a DBSCANClusterer.
|
DBSCANClusterer(double eps,
int minPts,
DistanceMeasure measure)
Creates a new instance of a DBSCANClusterer.
|
FuzzyKMeansClusterer(int k,
double fuzziness)
Creates a new instance of a FuzzyKMeansClusterer.
|
FuzzyKMeansClusterer(int k,
double fuzziness,
int maxIterations,
DistanceMeasure measure)
Creates a new instance of a FuzzyKMeansClusterer.
|
FuzzyKMeansClusterer(int k,
double fuzziness,
int maxIterations,
DistanceMeasure measure,
double epsilon,
RandomGenerator random)
Creates a new instance of a FuzzyKMeansClusterer.
|
| Modifier and Type | Method and Description |
|---|---|
double |
CanberraDistance.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 |
DistanceMeasure.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 |
EarthMoversDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
double |
ChebyshevDistance.compute(double[] a,
double[] b)
Compute the distance between two n-dimensional vectors.
|
| Modifier and Type | Method and Description |
|---|---|
void |
RootsOfUnity.computeRoots(int n)
Computes the
n-th roots of unity. |
StringBuffer |
ComplexFormat.format(Object obj,
StringBuffer toAppendTo,
FieldPosition pos)
Formats a object to produce a string.
|
double |
RootsOfUnity.getImaginary(int k)
Get the imaginary part of the
k-th n-th root of unity. |
static ComplexFormat |
ComplexFormat.getInstance(String imaginaryCharacter,
Locale locale)
Returns the default complex format for the given locale.
|
double |
RootsOfUnity.getReal(int k)
Get the real part of the
k-th n-th root of unity. |
List<Complex> |
Complex.nthRoot(int n)
Computes the n-th roots of this complex number.
|
static Complex |
ComplexUtils.polar2Complex(double r,
double theta)
Creates a complex number from the given polar representation.
|
| Constructor and Description |
|---|
ComplexFormat(String imaginaryCharacter)
Create an instance with a custom imaginary character, and the default
number format for both real and imaginary parts.
|
ComplexFormat(String imaginaryCharacter,
NumberFormat format)
Create an instance with a custom imaginary character, and a custom number
format for both real and imaginary parts.
|
ComplexFormat(String imaginaryCharacter,
NumberFormat realFormat,
NumberFormat imaginaryFormat)
Create an instance with a custom imaginary character, a custom number
format for the real part, and a custom number format for the imaginary
part.
|
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 |
RealDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
int |
IntegerDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
RealDistribution.probability(double x0,
double x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
double |
IntegerDistribution.probability(int x0,
int x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
double[][] |
MultivariateRealDistribution.sample(int sampleSize)
Generates a list of a random value vectors from the distribution.
|
| Constructor and Description |
|---|
EnumeratedDistribution(List<Pair<T,Double>> pmf)
Create an enumerated distribution using the given probability mass function
enumeration.
|
| Modifier and Type | Method and Description |
|---|---|
double |
EnumeratedRealDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
UniformRealDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
LaplaceDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
NormalDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
CauchyDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
ExponentialDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
AbstractRealDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
LogisticDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
ConstantRealDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
GumbelDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
LevyDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
TriangularDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
NormalDistribution.probability(double x0,
double x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
double |
AbstractRealDistribution.probability(double x0,
double x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
double |
LogNormalDistribution.probability(double x0,
double x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
| Constructor and Description |
|---|
CauchyDistribution(double median,
double scale)
Creates a Cauchy distribution.
|
EnumeratedRealDistribution(double[] singletons,
double[] probabilities)
Create a discrete real-valued distribution using the given probability mass function
enumeration.
|
ExponentialDistribution(double mean)
Create an exponential distribution with the given mean.
|
FDistribution(double numeratorDegreesOfFreedom,
double denominatorDegreesOfFreedom)
Creates an F distribution using the given degrees of freedom.
|
FDistribution(double numeratorDegreesOfFreedom,
double denominatorDegreesOfFreedom,
double inverseCumAccuracy)
Creates an F distribution.
|
GammaDistribution(double shape,
double scale)
Creates a new gamma distribution with specified values of the shape and
scale parameters.
|
GammaDistribution(double shape,
double scale,
double inverseCumAccuracy)
Creates a Gamma distribution.
|
GumbelDistribution(double mu,
double beta)
Build a new instance.
|
LaplaceDistribution(double mu,
double beta)
Build a new instance.
|
LogisticDistribution(double mu,
double s)
Build a new instance.
|
LogNormalDistribution(double scale,
double shape)
Create a log-normal distribution using the specified scale and shape.
|
LogNormalDistribution(double scale,
double shape,
double inverseCumAccuracy)
Creates a log-normal distribution.
|
NakagamiDistribution(double mu,
double omega)
Build a new instance.
|
NakagamiDistribution(double mu,
double omega,
double inverseAbsoluteAccuracy)
Build a new instance.
|
NormalDistribution(double mean,
double sd)
Create a normal distribution using the given mean, standard deviation.
|
ParetoDistribution(double scale,
double shape)
Create a Pareto distribution using the specified scale and shape.
|
ParetoDistribution(double scale,
double shape,
double inverseCumAccuracy)
Creates a Pareto distribution.
|
TDistribution(double degreesOfFreedom)
Create a t distribution using the given degrees of freedom.
|
TDistribution(double degreesOfFreedom,
double inverseCumAccuracy)
Create a t distribution using the given degrees of freedom and the
specified inverse cumulative probability absolute accuracy.
|
TriangularDistribution(double a,
double c,
double b)
Creates a triangular real distribution using the given lower limit,
upper limit, and mode.
|
UniformRealDistribution(double lower,
double upper)
Create a uniform real distribution using the given lower and upper
bounds.
|
WeibullDistribution(double alpha,
double beta)
Create a Weibull distribution with the given shape and scale.
|
| Modifier and Type | Method and Description |
|---|---|
int |
GeometricDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
int |
AbstractIntegerDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
double |
AbstractIntegerDistribution.probability(int x0,
int x1)
For a random variable
X whose values are distributed according
to this distribution, this method returns P(x0 < X <= x1). |
| Constructor and Description |
|---|
BinomialDistribution(int trials,
double p)
Create a binomial distribution with the given number of trials and
probability of success.
|
EnumeratedIntegerDistribution(int[] singletons,
double[] probabilities)
Create a discrete distribution using the given probability mass function
definition.
|
GeometricDistribution(double p)
Create a geometric distribution with the given probability of success.
|
HypergeometricDistribution(int populationSize,
int numberOfSuccesses,
int sampleSize)
Construct a new hypergeometric distribution with the specified population
size, number of successes in the population, and sample size.
|
PascalDistribution(int r,
double p)
Create a Pascal distribution with the given number of successes and
probability of success.
|
PoissonDistribution(double p)
Creates a new Poisson distribution with specified mean.
|
PoissonDistribution(double p,
double epsilon)
Creates a new Poisson distribution with the specified mean and
convergence criterion.
|
PoissonDistribution(double p,
double epsilon,
int maxIterations)
Creates a new Poisson distribution with specified mean, convergence
criterion and maximum number of iterations.
|
UniformIntegerDistribution(int lower,
int upper)
Creates a new uniform integer distribution using the given lower and
upper bounds (both inclusive).
|
ZipfDistribution(int numberOfElements,
double exponent)
Create a new Zipf distribution with the given number of elements and
exponent.
|
| 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 |
|---|
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 |
|---|---|
StringBuffer |
FractionFormat.format(Object obj,
StringBuffer toAppendTo,
FieldPosition pos)
Formats an object and appends the result to a StringBuffer.
|
| Constructor and Description |
|---|
BigFraction(double value)
Create a fraction given the double value.
|
| Modifier and Type | Method and Description |
|---|---|
void |
FieldLine.reset(FieldVector3D<T> p1,
FieldVector3D<T> p2)
Reset the instance as if built from two points.
|
void |
Line.reset(Vector3D p1,
Vector3D p2)
Reset the instance as if built from two points.
|
| Constructor and Description |
|---|
FieldLine(FieldVector3D<T> p1,
FieldVector3D<T> p2,
double tolerance)
Build a line from two points.
|
FieldRotation(FieldVector3D<T> axis,
T angle)
Deprecated.
as of 3.6, replaced with
FieldRotation.FieldRotation(FieldVector3D, RealFieldElement, RotationConvention) |
FieldRotation(FieldVector3D<T> axis,
T angle,
RotationConvention convention)
Build a rotation from an axis and an angle.
|
FieldRotation(T[][] m,
double threshold)
Build a rotation from a 3X3 matrix.
|
FieldVector3D(T[] v)
Simple constructor.
|
Line(Vector3D p1,
Vector3D p2,
double tolerance)
Build a line from two points.
|
Rotation(double[][] m,
double threshold)
Build a rotation from a 3X3 matrix.
|
Rotation(Vector3D axis,
double angle)
Deprecated.
as of 3.6, replaced with
Rotation.Rotation(Vector3D, double, RotationConvention) |
Rotation(Vector3D axis,
double angle,
RotationConvention convention)
Build a rotation from an axis and an angle.
|
SubLine(Segment segment)
Create a sub-line from a segment.
|
SubLine(Vector3D start,
Vector3D end,
double tolerance)
Create a sub-line from two endpoints.
|
Vector3D(double[] v)
Simple constructor.
|
| Modifier and Type | Method and Description |
|---|---|
static Transform<Euclidean2D,Euclidean1D> |
Line.getTransform(double cXX,
double cYX,
double cXY,
double cYY,
double cX1,
double cY1)
Get a
Transform embedding an affine transform. |
| Constructor and Description |
|---|
Vector2D(double[] v)
Simple constructor.
|
| Modifier and Type | Method and Description |
|---|---|
Region<Euclidean2D> |
ConvexHull2D.createRegion()
Returns a new region that is enclosed by the convex hull.
|
| Constructor and Description |
|---|
ConvexHull2D(Vector2D[] vertices,
double tolerance)
Simple constructor.
|
| Modifier and Type | Method and Description |
|---|---|
Region<S> |
ConvexHull.createRegion()
Returns a new region that is enclosed by the convex hull.
|
| Modifier and Type | Class and Description |
|---|---|
static class |
ArcsSet.InconsistentStateAt2PiWrapping
Specialized exception for inconsistent BSP tree state inconsistency.
|
| Constructor and Description |
|---|
Arc(double lower,
double upper,
double tolerance)
Simple constructor.
|
ArcsSet(double lower,
double upper,
double tolerance)
Build an arcs set corresponding to a single arc.
|
| Constructor and Description |
|---|
S2Point(double theta,
double phi)
Simple constructor.
|
| Modifier and Type | Method and Description |
|---|---|
Array2DRowFieldMatrix<T> |
Array2DRowFieldMatrix.add(Array2DRowFieldMatrix<T> m)
Add
m to this matrix. |
Array2DRowRealMatrix |
Array2DRowRealMatrix.add(Array2DRowRealMatrix m)
Compute the sum of
this and m. |
ArrayFieldVector<T> |
ArrayFieldVector.add(ArrayFieldVector<T> v)
Compute the sum of
this and v. |
BlockFieldMatrix<T> |
BlockFieldMatrix.add(BlockFieldMatrix<T> m)
Compute the sum of
this and m. |
BlockRealMatrix |
BlockRealMatrix.add(BlockRealMatrix m)
Compute the sum of this matrix and
m. |
DiagonalMatrix |
DiagonalMatrix.add(DiagonalMatrix m)
Compute the sum of
this and m. |
FieldMatrix<T> |
BlockFieldMatrix.add(FieldMatrix<T> m)
Compute the sum of this and m.
|
FieldMatrix<T> |
FieldMatrix.add(FieldMatrix<T> m)
Compute the sum of this and m.
|
FieldMatrix<T> |
AbstractFieldMatrix.add(FieldMatrix<T> m)
Compute the sum of this and m.
|
FieldVector<T> |
ArrayFieldVector.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> |
FieldVector.add(FieldVector<T> v)
Compute the sum of
this and v. |
OpenMapRealMatrix |
OpenMapRealMatrix.add(OpenMapRealMatrix m)
Compute the sum of this matrix and
m. |
OpenMapRealVector |
OpenMapRealVector.add(OpenMapRealVector v)
Optimized method to add two OpenMapRealVectors.
|
RealMatrix |
RealMatrix.add(RealMatrix m)
Returns the sum of
this and m. |
RealMatrix |
AbstractRealMatrix.add(RealMatrix m)
Returns the sum of
this and m. |
BlockRealMatrix |
BlockRealMatrix.add(RealMatrix m)
Returns the sum of
this and m. |
ArrayRealVector |
ArrayRealVector.add(RealVector v)
Compute the sum of this vector and
v. |
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. |
FieldVector<T> |
SparseFieldVector.add(SparseFieldVector<T> v)
Optimized method to add sparse vectors.
|
void |
ArrayRealVector.addToEntry(int index,
double increment)
Change an entry at the specified index.
|
void |
RealVector.addToEntry(int index,
double increment)
Change an entry at the specified index.
|
void |
RealMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
Array2DRowRealMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
AbstractRealMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
DiagonalMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
BlockRealMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
OpenMapRealMatrix.addToEntry(int row,
int column,
double increment)
Adds (in place) the specified value to the specified entry of
this matrix. |
void |
BlockFieldMatrix.addToEntry(int row,
int column,
T increment)
Change an entry in the specified row and column.
|
void |
FieldMatrix.addToEntry(int row,
int column,
T increment)
Change an entry in the specified row and column.
|
void |
Array2DRowFieldMatrix.addToEntry(int row,
int column,
T increment)
Change an entry in the specified row and column.
|
abstract void |
AbstractFieldMatrix.addToEntry(int row,
int column,
T increment)
Change an entry in the specified row and column.
|
static void |
MatrixUtils.checkAdditionCompatible(AnyMatrix left,
AnyMatrix right)
Check if matrices are addition compatible.
|
protected void |
AbstractFieldMatrix.checkAdditionCompatible(FieldMatrix<T> m)
Check if a matrix is addition compatible with the instance.
|
static void |
MatrixUtils.checkColumnIndex(AnyMatrix m,
int column)
Check if a column index is valid.
|
protected void |
AbstractFieldMatrix.checkColumnIndex(int column)
Check if a column index is valid.
|
protected void |
RealVector.checkIndex(int index)
Check if an index is valid.
|
protected void |
RealVector.checkIndices(int start,
int end)
Checks that the indices of a subvector are valid.
|
static void |
MatrixUtils.checkMatrixIndex(AnyMatrix m,
int row,
int column)
Check if matrix indices are valid.
|
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. |
static void |
MatrixUtils.checkRowIndex(AnyMatrix m,
int row)
Check if a row index is valid.
|
protected void |
AbstractFieldMatrix.checkRowIndex(int row)
Check if a row index is valid.
|
static void |
MatrixUtils.checkSubMatrixIndex(AnyMatrix m,
int[] selectedRows,
int[] selectedColumns)
Check if submatrix ranges indices are valid.
|
static void |
MatrixUtils.checkSubMatrixIndex(AnyMatrix m,
int startRow,
int endRow,
int startColumn,
int endColumn)
Check if submatrix ranges indices are valid.
|
protected void |
AbstractFieldMatrix.checkSubMatrixIndex(int[] selectedRows,
int[] selectedColumns)
Check if submatrix ranges indices are valid.
|
protected void |
AbstractFieldMatrix.checkSubMatrixIndex(int startRow,
int endRow,
int startColumn,
int endColumn)
Check if submatrix ranges indices are valid.
|
static void |
MatrixUtils.checkSubtractionCompatible(AnyMatrix left,
AnyMatrix right)
Check if matrices are subtraction compatible
|
protected void |
AbstractFieldMatrix.checkSubtractionCompatible(FieldMatrix<T> m)
Check if a matrix is subtraction compatible with the instance.
|
protected void |
ArrayFieldVector.checkVectorDimensions(FieldVector<T> v)
Check if instance and specified vectors have the same dimension.
|
protected void |
ArrayRealVector.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 |
SparseFieldVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
RealVector.checkVectorDimensions(int n)
Check if instance dimension is equal to some expected value.
|
protected void |
ArrayRealVector.checkVectorDimensions(RealVector v)
Check if instance and specified vectors have the same dimension.
|
protected void |
RealVector.checkVectorDimensions(RealVector v)
Check if instance and specified vectors have the same dimension.
|
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.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.combineToSelf(double a,
double b,
RealVector y)
Updates
this with 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. |
void |
RealMatrix.copySubMatrix(int[] selectedRows,
int[] selectedColumns,
double[][] destination)
Copy a submatrix.
|
void |
AbstractRealMatrix.copySubMatrix(int[] selectedRows,
int[] selectedColumns,
double[][] destination)
Copy a submatrix.
|
void |
FieldMatrix.copySubMatrix(int[] selectedRows,
int[] selectedColumns,
T[][] destination)
Copy a submatrix.
|
void |
AbstractFieldMatrix.copySubMatrix(int[] selectedRows,
int[] selectedColumns,
T[][] destination)
Copy a submatrix.
|
void |
RealMatrix.copySubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn,
double[][] destination)
Copy a submatrix.
|
void |
AbstractRealMatrix.copySubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn,
double[][] destination)
Copy a submatrix.
|
void |
FieldMatrix.copySubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn,
T[][] destination)
Copy a submatrix.
|
void |
AbstractFieldMatrix.copySubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn,
T[][] destination)
Copy a submatrix.
|
double |
RealVector.cosine(RealVector v)
Computes the cosine of the angle between this vector and the
argument.
|
static JacobiPreconditioner |
JacobiPreconditioner.create(RealLinearOperator a)
Creates a new instance of this class.
|
static <T extends FieldElement<T>> |
MatrixUtils.createColumnFieldMatrix(T[] columnData)
Creates a column
FieldMatrix using the data from the input
array. |
static RealMatrix |
MatrixUtils.createColumnRealMatrix(double[] columnData)
Creates a column
RealMatrix using the data from the input
array. |
static <T extends FieldElement<T>> |
MatrixUtils.createFieldMatrix(T[][] data)
Returns a
FieldMatrix whose entries are the the values in the
the input array. |
static <T extends FieldElement<T>> |
MatrixUtils.createFieldVector(T[] data)
Creates a
FieldVector using the data from the input array. |
FieldMatrix<T> |
BlockFieldMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new FieldMatrix
|
RealMatrix |
RealMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix of the same type as the instance with the
supplied
row and column dimensions.
|
RealMatrix |
Array2DRowRealMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix of the same type as the instance with the
supplied
row and column dimensions.
|
FieldMatrix<T> |
FieldMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new FieldMatrix
|
FieldMatrix<T> |
Array2DRowFieldMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new FieldMatrix
|
abstract RealMatrix |
AbstractRealMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix of the same type as the instance with the
supplied
row and column dimensions.
|
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.
|
abstract FieldMatrix<T> |
AbstractFieldMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new FieldMatrix
|
BlockRealMatrix |
BlockRealMatrix.createMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix of the same type as the instance with the
supplied
row and column dimensions.
|
OpenMapRealMatrix |
OpenMapRealMatrix.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. |
static RealVector |
MatrixUtils.createRealVector(double[] data)
Creates a
RealVector using the data from the input array. |
static <T extends FieldElement<T>> |
MatrixUtils.createRowFieldMatrix(T[] rowData)
Create a row
FieldMatrix using the data from the input
array. |
static RealMatrix |
MatrixUtils.createRowRealMatrix(double[] rowData)
Create a row
RealMatrix using the data from the input
array. |
T |
ArrayFieldVector.dotProduct(ArrayFieldVector<T> v)
Compute the dot product.
|
T |
ArrayFieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
T |
SparseFieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
T |
FieldVector.dotProduct(FieldVector<T> v)
Compute the dot product.
|
double |
ArrayRealVector.dotProduct(RealVector v)
Compute the dot product of this vector with
v. |
double |
RealVector.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> |
ArrayFieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
FieldVector<T> |
SparseFieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
FieldVector<T> |
FieldVector.ebeDivide(FieldVector<T> v)
Element-by-element division.
|
ArrayRealVector |
ArrayRealVector.ebeDivide(RealVector v)
Element-by-element division.
|
abstract RealVector |
RealVector.ebeDivide(RealVector v)
Element-by-element division.
|
OpenMapRealVector |
OpenMapRealVector.ebeDivide(RealVector v)
Element-by-element division.
|
ArrayFieldVector<T> |
ArrayFieldVector.ebeMultiply(ArrayFieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
ArrayFieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
SparseFieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
FieldVector<T> |
FieldVector.ebeMultiply(FieldVector<T> v)
Element-by-element multiplication.
|
ArrayRealVector |
ArrayRealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
abstract RealVector |
RealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
OpenMapRealVector |
OpenMapRealVector.ebeMultiply(RealVector v)
Element-by-element multiplication.
|
protected static <T extends FieldElement<T>> |
AbstractFieldMatrix.extractField(T[] d)
Get the elements type from an array.
|
protected static <T extends FieldElement<T>> |
AbstractFieldMatrix.extractField(T[][] d)
Get the elements type from an array.
|
T[] |
BlockFieldMatrix.getColumn(int column)
Get the entries in column number
col as an array. |
double[] |
RealMatrix.getColumn(int column)
Get the entries at the given column index as an array.
|
T[] |
FieldMatrix.getColumn(int column)
Get the entries in column number
col as an array. |
double[] |
AbstractRealMatrix.getColumn(int column)
Get the entries at the given column index as an array.
|
T[] |
AbstractFieldMatrix.getColumn(int column)
Get the entries in column number
col as an array. |
double[] |
BlockRealMatrix.getColumn(int column)
Get the entries at the given column index as an array.
|
FieldMatrix<T> |
BlockFieldMatrix.getColumnMatrix(int column)
Get the entries in column number
column
as a column matrix. |
RealMatrix |
RealMatrix.getColumnMatrix(int column)
Get the entries at the given column index as a column matrix.
|
FieldMatrix<T> |
FieldMatrix.getColumnMatrix(int column)
Get the entries in column number
column
as a column matrix. |
RealMatrix |
AbstractRealMatrix.getColumnMatrix(int column)
Get the entries at the given column index as a column matrix.
|
FieldMatrix<T> |
AbstractFieldMatrix.getColumnMatrix(int column)
Get the entries in column number
column
as a column matrix. |
BlockRealMatrix |
BlockRealMatrix.getColumnMatrix(int column)
Get the entries at the given column index as a column matrix.
|
FieldVector<T> |
BlockFieldMatrix.getColumnVector(int column)
Returns the entries in column number
column
as a vector. |
RealVector |
RealMatrix.getColumnVector(int column)
Get the entries at the given column index as a vector.
|
FieldVector<T> |
FieldMatrix.getColumnVector(int column)
Returns the entries in column number
column
as a vector. |
RealVector |
AbstractRealMatrix.getColumnVector(int column)
Get the entries at the given column index as a vector.
|
FieldVector<T> |
AbstractFieldMatrix.getColumnVector(int column)
Returns the entries in column number
column
as a vector. |
RealVector |
BlockRealMatrix.getColumnVector(int column)
Get the entries at the given column index as a vector.
|
double |
OpenMapRealVector.getDistance(OpenMapRealVector v)
Optimized method to compute distance.
|
double |
ArrayRealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
RealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getDistance(RealVector v)
Distance between two vectors.
|
double |
ArrayRealVector.getEntry(int index)
Return the entry at the specified index.
|
T |
SparseFieldVector.getEntry(int index)
Returns the entry in the specified index.
|
T |
FieldVector.getEntry(int index)
Returns the entry in the specified index.
|
abstract double |
RealVector.getEntry(int index)
Return the entry at the specified index.
|
double |
OpenMapRealVector.getEntry(int index)
Return the entry at the specified index.
|
T |
BlockFieldMatrix.getEntry(int row,
int column)
Returns the entry in the specified row and column.
|
double |
RealMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
double |
Array2DRowRealMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
T |
FieldMatrix.getEntry(int row,
int column)
Returns the entry in the specified row and column.
|
T |
Array2DRowFieldMatrix.getEntry(int row,
int column)
Returns the entry in the specified row and column.
|
abstract double |
AbstractRealMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
double |
DiagonalMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
abstract T |
AbstractFieldMatrix.getEntry(int row,
int column)
Returns the entry in the specified row and column.
|
double |
BlockRealMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
double |
OpenMapRealMatrix.getEntry(int row,
int column)
Get the entry in the specified row and column.
|
RealMatrix |
DecompositionSolver.getInverse()
Get the pseudo-inverse
of the decomposed matrix.
|
double |
OpenMapRealVector.getL1Distance(OpenMapRealVector v)
Distance between two vectors.
|
double |
ArrayRealVector.getL1Distance(RealVector 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.getLInfDistance(RealVector v)
Distance between two vectors.
|
double |
RealVector.getLInfDistance(RealVector v)
Distance between two vectors.
|
double |
OpenMapRealVector.getLInfDistance(RealVector v)
Distance between two vectors.
|
T[] |
BlockFieldMatrix.getRow(int row)
Get the entries in row number
row as an array. |
double[] |
RealMatrix.getRow(int row)
Get the entries at the given row index.
|
double[] |
Array2DRowRealMatrix.getRow(int row)
Get the entries at the given row index.
|
T[] |
FieldMatrix.getRow(int row)
Get the entries in row number
row as an array. |
T[] |
Array2DRowFieldMatrix.getRow(int row)
Get the entries in row number
row as an array. |
double[] |
AbstractRealMatrix.getRow(int row)
Get the entries at the given row index.
|
T[] |
AbstractFieldMatrix.getRow(int row)
Get the entries in row number
row as an array. |
double[] |
BlockRealMatrix.getRow(int row)
Get the entries at the given row index.
|
FieldMatrix<T> |
BlockFieldMatrix.getRowMatrix(int row)
Get the entries in row number
row
as a row matrix. |
RealMatrix |
RealMatrix.getRowMatrix(int row)
Get the entries at the given row index as a row matrix.
|
FieldMatrix<T> |
FieldMatrix.getRowMatrix(int row)
Get the entries in row number
row
as a row matrix. |
RealMatrix |
AbstractRealMatrix.getRowMatrix(int row)
Get the entries at the given row index as a row matrix.
|
FieldMatrix<T> |
AbstractFieldMatrix.getRowMatrix(int row)
Get the entries in row number
row
as a row matrix. |
BlockRealMatrix |
BlockRealMatrix.getRowMatrix(int row)
Get the entries at the given row index as a row matrix.
|
FieldVector<T> |
BlockFieldMatrix.getRowVector(int row)
Get the entries in row number
row
as a vector. |
RealVector |
RealMatrix.getRowVector(int row)
Returns the entries in row number
row as a vector. |
FieldVector<T> |
FieldMatrix.getRowVector(int row)
Get the entries in row number
row
as a vector. |
RealVector |
AbstractRealMatrix.getRowVector(int row)
Returns the entries in row number
row as a vector. |
FieldVector<T> |
AbstractFieldMatrix.getRowVector(int row)
Get the entries in row number
row
as a vector. |
RealVector |
BlockRealMatrix.getRowVector(int row)
Returns the entries in row number
row as a vector. |
RealMatrix |
RealMatrix.getSubMatrix(int[] selectedRows,
int[] selectedColumns)
Gets a submatrix.
|
FieldMatrix<T> |
FieldMatrix.getSubMatrix(int[] selectedRows,
int[] selectedColumns)
Get a submatrix.
|
RealMatrix |
AbstractRealMatrix.getSubMatrix(int[] selectedRows,
int[] selectedColumns)
Gets a submatrix.
|
FieldMatrix<T> |
AbstractFieldMatrix.getSubMatrix(int[] selectedRows,
int[] selectedColumns)
Get a submatrix.
|
FieldMatrix<T> |
BlockFieldMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Get a submatrix.
|
RealMatrix |
RealMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Gets a submatrix.
|
RealMatrix |
Array2DRowRealMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Gets a submatrix.
|
FieldMatrix<T> |
FieldMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Get a submatrix.
|
FieldMatrix<T> |
Array2DRowFieldMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Get a submatrix.
|
RealMatrix |
AbstractRealMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Gets a submatrix.
|
FieldMatrix<T> |
AbstractFieldMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Get a submatrix.
|
BlockRealMatrix |
BlockRealMatrix.getSubMatrix(int startRow,
int endRow,
int startColumn,
int endColumn)
Gets a submatrix.
|
RealVector |
ArrayRealVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
FieldVector<T> |
ArrayFieldVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
FieldVector<T> |
SparseFieldVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
FieldVector<T> |
FieldVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
abstract RealVector |
RealVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
OpenMapRealVector |
OpenMapRealVector.getSubVector(int index,
int n)
Get a subvector from consecutive elements.
|
double |
RealMatrix.getTrace()
Returns the
trace of the matrix (the sum of the elements on the main diagonal).
|
T |
FieldMatrix.getTrace()
Returns the
trace of the matrix (the sum of the elements on the main diagonal).
|
double |
AbstractRealMatrix.getTrace()
Returns the
trace of the matrix (the sum of the elements on the main diagonal).
|
T |
AbstractFieldMatrix.getTrace()
Returns the
trace of the matrix (the sum of the elements on the main diagonal).
|
DiagonalMatrix |
DiagonalMatrix.inverse()
Computes the inverse of this diagonal matrix.
|
DiagonalMatrix |
DiagonalMatrix.inverse(double threshold)
Computes the inverse of this diagonal matrix.
|
static RealMatrix |
MatrixUtils.inverse(RealMatrix matrix)
Computes the inverse of the given matrix.
|
static RealMatrix |
MatrixUtils.inverse(RealMatrix matrix,
double threshold)
Computes the inverse of the given matrix.
|
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> |
BlockFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
FieldMatrix<T> |
FieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
FieldMatrix<T> |
AbstractFieldMatrix.multiply(FieldMatrix<T> m)
Postmultiply this matrix by
m. |
OpenMapRealMatrix |
OpenMapRealMatrix.multiply(OpenMapRealMatrix m)
Postmultiply this matrix by
m. |
RealMatrix |
RealMatrix.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 |
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 |
OpenMapRealMatrix.multiply(RealMatrix m)
Returns the result of postmultiplying
this by m. |
void |
RealMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
Array2DRowRealMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
AbstractRealMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
DiagonalMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
BlockRealMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
OpenMapRealMatrix.multiplyEntry(int row,
int column,
double factor)
Multiplies (in place) the specified entry of
this matrix by the
specified value. |
void |
BlockFieldMatrix.multiplyEntry(int row,
int column,
T factor)
Change an entry in the specified row and column.
|
void |
FieldMatrix.multiplyEntry(int row,
int column,
T factor)
Change an entry in the specified row and column.
|
void |
Array2DRowFieldMatrix.multiplyEntry(int row,
int column,
T factor)
Change an entry in the specified row and column.
|
abstract void |
AbstractFieldMatrix.multiplyEntry(int row,
int column,
T factor)
Change an entry in the specified row and column.
|
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. |
double[] |
AbstractRealMatrix.operate(double[] v)
Returns the result of multiplying this by the vector
v. |
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. |
FieldVector<T> |
FieldMatrix.operate(FieldVector<T> 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. |
RealVector |
RealMatrix.operate(RealVector v)
Returns the result of multiplying this by the vector
v. |
RealVector |
AbstractRealMatrix.operate(RealVector v)
Returns the result of multiplying this by the vector
v. |
RealVector |
RealLinearOperator.operate(RealVector x)
Returns the result of multiplying
this by the vector x. |
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. |
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. |
default RealVector |
RealLinearOperator.operateTranspose(RealVector x)
Returns the result of multiplying the transpose of
this operator
by the vector x (optional operation). |
RealMatrix |
RealMatrix.power(int p)
Returns the result of multiplying
this with itself p
times. |
FieldMatrix<T> |
FieldMatrix.power(int p)
Returns the result multiplying this with itself
p times. |
RealMatrix |
AbstractRealMatrix.power(int p)
Returns the result of multiplying
this with itself p
times. |
FieldMatrix<T> |
AbstractFieldMatrix.power(int p)
Returns the result multiplying this with itself
p times. |
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. |
double[] |
AbstractRealMatrix.preMultiply(double[] v)
Returns the (row) vector result of premultiplying this by the vector
v. |
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. |
FieldMatrix<T> |
FieldMatrix.preMultiply(FieldMatrix<T> m)
Premultiply this matrix by
m. |
FieldMatrix<T> |
AbstractFieldMatrix.preMultiply(FieldMatrix<T> m)
Premultiply this matrix by
m. |
FieldVector<T> |
FieldMatrix.preMultiply(FieldVector<T> v)
Returns the (row) vector result of premultiplying this by the vector
v. |
FieldVector<T> |
AbstractFieldMatrix.preMultiply(FieldVector<T> v)
Returns the (row) vector result of premultiplying this by the vector
v. |
RealMatrix |
RealMatrix.preMultiply(RealMatrix m)
Returns the result of premultiplying
this by m. |
RealMatrix |
AbstractRealMatrix.preMultiply(RealMatrix m)
Returns the result of premultiplying
this by m. |
RealVector |
RealMatrix.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 |
DiagonalMatrix.preMultiply(RealVector 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. |
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. |
ArrayFieldVector<T> |
ArrayFieldVector.projection(ArrayFieldVector<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.
|
FieldVector<T> |
SparseFieldVector.projection(FieldVector<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.
|
RealVector |
RealVector.projection(RealVector v)
Find the orthogonal projection of this vector onto another vector.
|
void |
ArrayFieldVector.set(int index,
ArrayFieldVector<T> v)
Set a set of consecutive elements.
|
void |
RealMatrix.setColumn(int column,
double[] array)
Sets the specified
column of this matrix to the entries
of the specified array. |
void |
AbstractRealMatrix.setColumn(int column,
double[] array)
Sets the specified
column of this matrix to the entries
of the specified array. |
void |
BlockRealMatrix.setColumn(int column,
double[] array)
Sets the specified
column of this matrix to the entries
of the specified array. |
void |
BlockFieldMatrix.setColumn(int column,
T[] array)
Set the entries in column number
column
as a column matrix. |
void |
FieldMatrix.setColumn(int column,
T[] array)
Set the entries in column number
column
as a column matrix. |
void |
AbstractFieldMatrix.setColumn(int column,
T[] array)
Set the entries in column number
column
as a column matrix. |
void |
BlockFieldMatrix.setColumnMatrix(int column,
FieldMatrix<T> matrix)
Set the entries in column number
column
as a column matrix. |
void |
FieldMatrix.setColumnMatrix(int column,
FieldMatrix<T> matrix)
Set the entries in column number
column
as a column matrix. |
void |
AbstractFieldMatrix.setColumnMatrix(int column,
FieldMatrix<T> matrix)
Set the entries in column number
column
as a column matrix. |
void |
RealMatrix.setColumnMatrix(int column,
RealMatrix matrix)
Sets the specified
column of this matrix to the entries
of the specified column matrix. |
void |
AbstractRealMatrix.setColumnMatrix(int column,
RealMatrix matrix)
Sets the specified
column of this matrix to the entries
of the specified column matrix. |
void |
BlockRealMatrix.setColumnMatrix(int column,
RealMatrix matrix)
Sets the specified
column of this matrix to the entries
of the specified column matrix. |
void |
BlockFieldMatrix.setColumnVector(int column,
FieldVector<T> vector)
Set the entries in column number
column
as a vector. |
void |
FieldMatrix.setColumnVector(int column,
FieldVector<T> vector)
Set the entries in column number
column
as a vector. |
void |
AbstractFieldMatrix.setColumnVector(int column,
FieldVector<T> vector)
Set the entries in column number
column
as a vector. |
void |
RealMatrix.setColumnVector(int column,
RealVector vector)
Sets the specified
column of this matrix to the entries
of the specified vector. |
void |
AbstractRealMatrix.setColumnVector(int column,
RealVector vector)
Sets the specified
column of this matrix to the entries
of the specified vector. |
void |
BlockRealMatrix.setColumnVector(int column,
RealVector vector)
Sets the specified
column of this matrix to the entries
of the specified vector. |
void |
ArrayRealVector.setEntry(int index,
double value)
Set a single element.
|
abstract void |
RealVector.setEntry(int index,
double value)
Set a single element.
|
void |
OpenMapRealVector.setEntry(int index,
double value)
Set a single element.
|
void |
RealMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
void |
Array2DRowRealMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
abstract void |
AbstractRealMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
void |
DiagonalMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
void |
BlockRealMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
void |
OpenMapRealMatrix.setEntry(int row,
int column,
double value)
Set the entry in the specified row and column.
|
void |
BlockFieldMatrix.setEntry(int row,
int column,
T value)
Set the entry in the specified row and column.
|
void |
FieldMatrix.setEntry(int row,
int column,
T value)
Set the entry in the specified row and column.
|
void |
Array2DRowFieldMatrix.setEntry(int row,
int column,
T value)
Set the entry in the specified row and column.
|
abstract void |
AbstractFieldMatrix.setEntry(int row,
int column,
T value)
Set the entry in the specified row and column.
|
void |
SparseFieldVector.setEntry(int index,
T value)
Set a single element.
|
void |
FieldVector.setEntry(int index,
T value)
Set a single element.
|
void |
RealMatrix.setRow(int row,
double[] array)
Sets the specified
row of this matrix to the entries
of the specified array. |
void |
Array2DRowRealMatrix.setRow(int row,
double[] array)
Sets the specified
row of this matrix to the entries
of the specified array. |
void |
AbstractRealMatrix.setRow(int row,
double[] array)
Sets the specified
row of this matrix to the entries
of the specified array. |
void |
BlockRealMatrix.setRow(int row,
double[] array)
Sets the specified
row of this matrix to the entries
of the specified array. |
void |
BlockFieldMatrix.setRow(int row,
T[] array)
Set the entries in row number
row
as a row matrix. |
void |
FieldMatrix.setRow(int row,
T[] array)
Set the entries in row number
row
as a row matrix. |
void |
Array2DRowFieldMatrix.setRow(int row,
T[] array)
Set the entries in row number
row
as a row matrix. |
void |
AbstractFieldMatrix.setRow(int row,
T[] array)
Set the entries in row number
row
as a row matrix. |
void |
BlockFieldMatrix.setRowMatrix(int row,
BlockFieldMatrix<T> matrix)
Sets the entries in row number
row
as a row matrix. |
void |
BlockRealMatrix.setRowMatrix(int row,
BlockRealMatrix matrix)
Sets the entries in row number
row
as a row matrix. |
void |
BlockFieldMatrix.setRowMatrix(int row,
FieldMatrix<T> matrix)
Set the entries in row number
row
as a row matrix. |
void |
FieldMatrix.setRowMatrix(int row,
FieldMatrix<T> matrix)
Set the entries in row number
row
as a row matrix. |
void |
AbstractFieldMatrix.setRowMatrix(int row,
FieldMatrix<T> matrix)
Set the entries in row number
row
as a row matrix. |
void |
RealMatrix.setRowMatrix(int row,
RealMatrix matrix)
Sets the specified
row of this matrix to the entries of
the specified row matrix. |
void |
AbstractRealMatrix.setRowMatrix(int row,
RealMatrix matrix)
Sets the specified
row of this matrix to the entries of
the specified row matrix. |
void |
BlockRealMatrix.setRowMatrix(int row,
RealMatrix matrix)
Sets the specified
row of this matrix to the entries of
the specified row matrix. |
void |
BlockFieldMatrix.setRowVector(int row,
FieldVector<T> vector)
Set the entries in row number
row
as a vector. |
void |
FieldMatrix.setRowVector(int row,
FieldVector<T> vector)
Set the entries in row number
row
as a vector. |
void |
AbstractFieldMatrix.setRowVector(int row,
FieldVector<T> vector)
Set the entries in row number
row
as a vector. |
void |
RealMatrix.setRowVector(int row,
RealVector vector)
Sets the specified
row of this matrix to the entries of
the specified vector. |
void |
AbstractRealMatrix.setRowVector(int row,
RealVector vector)
Sets the specified
row of this matrix to the entries of
the specified vector. |
void |
BlockRealMatrix.setRowVector(int row,
RealVector vector)
Sets the specified
row of this matrix to the entries of
the specified vector. |
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 |
AbstractRealMatrix.setSubMatrix(double[][] subMatrix,
int row,
int column)
Replace the submatrix starting at
row, column using data in the
input subMatrix array. |
void |
BlockRealMatrix.setSubMatrix(double[][] 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. |
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 |
ArrayRealVector.setSubVector(int index,
double[] v)
Set a set of consecutive elements.
|
void |
ArrayFieldVector.setSubVector(int index,
FieldVector<T> v)
Set a set of consecutive elements.
|
void |
SparseFieldVector.setSubVector(int index,
FieldVector<T> v)
Set a set of consecutive elements.
|
void |
FieldVector.setSubVector(int index,
FieldVector<T> v)
Set a set of consecutive elements.
|
void |
ArrayRealVector.setSubVector(int index,
RealVector v)
Set a sequence of consecutive elements.
|
abstract void |
RealVector.setSubVector(int index,
RealVector v)
Set a sequence of consecutive elements.
|
void |
OpenMapRealVector.setSubVector(int index,
RealVector v)
Set a sequence of consecutive elements.
|
RealVector |
SymmLQ.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)
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 |
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 |
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 |
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.
|
RealMatrix |
DecompositionSolver.solve(RealMatrix b)
Solve the linear equation A × X = B for matrices A.
|
RealVector |
DecompositionSolver.solve(RealVector b)
Solve the linear equation A × X = B for matrices A.
|
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 |
SymmLQ.solveInPlace(RealLinearOperator a,
RealLinearOperator m,
RealVector b,
RealVector x)
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 |
ConjugateGradient.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.
|
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. |
Array2DRowFieldMatrix<T> |
Array2DRowFieldMatrix.subtract(Array2DRowFieldMatrix<T> m)
Subtract
m from this matrix. |
Array2DRowRealMatrix |
Array2DRowRealMatrix.subtract(Array2DRowRealMatrix m)
Returns
this minus m. |
ArrayFieldVector<T> |
ArrayFieldVector.subtract(ArrayFieldVector<T> v)
Compute
this minus v. |
BlockFieldMatrix<T> |
BlockFieldMatrix.subtract(BlockFieldMatrix<T> m)
Compute
this - m. |
BlockRealMatrix |
BlockRealMatrix.subtract(BlockRealMatrix m)
Subtract
m from this matrix. |
DiagonalMatrix |
DiagonalMatrix.subtract(DiagonalMatrix m)
Returns
this minus m. |
FieldMatrix<T> |
BlockFieldMatrix.subtract(FieldMatrix<T> m)
Subtract
m from this matrix. |
FieldMatrix<T> |
FieldMatrix.subtract(FieldMatrix<T> m)
Subtract
m from this matrix. |
FieldMatrix<T> |
AbstractFieldMatrix.subtract(FieldMatrix<T> m)
Subtract
m from this matrix. |
FieldVector<T> |
ArrayFieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
FieldVector<T> |
SparseFieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
FieldVector<T> |
FieldVector.subtract(FieldVector<T> v)
Compute
this minus v. |
OpenMapRealMatrix |
OpenMapRealMatrix.subtract(OpenMapRealMatrix m)
Subtract
m from this matrix. |
OpenMapRealVector |
OpenMapRealVector.subtract(OpenMapRealVector v)
Optimized method to subtract OpenMapRealVectors.
|
RealMatrix |
RealMatrix.subtract(RealMatrix m)
Returns
this minus m. |
RealMatrix |
AbstractRealMatrix.subtract(RealMatrix m)
Returns
this minus m. |
BlockRealMatrix |
BlockRealMatrix.subtract(RealMatrix m)
Returns
this minus m. |
OpenMapRealMatrix |
OpenMapRealMatrix.subtract(RealMatrix m)
Returns
this minus m. |
ArrayRealVector |
ArrayRealVector.subtract(RealVector v)
Subtract
v from this vector. |
RealVector |
RealVector.subtract(RealVector v)
Subtract
v from this vector. |
RealVector |
OpenMapRealVector.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.
|
T |
FieldMatrix.walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
T |
Array2DRowFieldMatrix.walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
T |
AbstractFieldMatrix.walkInColumnOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
T |
FieldMatrix.walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
T |
Array2DRowFieldMatrix.walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
T |
AbstractFieldMatrix.walkInColumnOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
double |
RealMatrix.walkInColumnOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
double |
Array2DRowRealMatrix.walkInColumnOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
double |
AbstractRealMatrix.walkInColumnOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in column order.
|
double |
RealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
double |
Array2DRowRealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
double |
AbstractRealMatrix.walkInColumnOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in column order.
|
T |
ArrayFieldVector.walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor,
int start,
int end)
Visits (and possibly alters) some entries of this vector in default order
(increasing index).
|
T |
SparseFieldVector.walkInDefaultOrder(FieldVectorChangingVisitor<T> visitor,
int start,
int end)
Visits (and possibly alters) some entries of this vector in default order
(increasing index).
|
T |
ArrayFieldVector.walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in default order
(increasing index).
|
T |
SparseFieldVector.walkInDefaultOrder(FieldVectorPreservingVisitor<T> visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in default order
(increasing index).
|
double |
ArrayRealVector.walkInDefaultOrder(RealVectorChangingVisitor visitor,
int start,
int end)
Visits (and possibly alters) some entries of this vector in default order
(increasing index).
|
double |
RealVector.walkInDefaultOrder(RealVectorChangingVisitor visitor,
int start,
int end)
Visits (and possibly alters) some entries of this vector in default order
(increasing index).
|
double |
ArrayRealVector.walkInDefaultOrder(RealVectorPreservingVisitor visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in default order
(increasing index).
|
double |
RealVector.walkInDefaultOrder(RealVectorPreservingVisitor visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in default order
(increasing index).
|
T |
BlockFieldMatrix.walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
T |
FieldMatrix.walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
T |
AbstractFieldMatrix.walkInOptimizedOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
T |
BlockFieldMatrix.walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
T |
FieldMatrix.walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
T |
AbstractFieldMatrix.walkInOptimizedOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
T |
ArrayFieldVector.walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor,
int start,
int end)
Visits (and possibly change) some entries of this vector in optimized
order.
|
T |
SparseFieldVector.walkInOptimizedOrder(FieldVectorChangingVisitor<T> visitor,
int start,
int end)
Visits (and possibly change) some entries of this vector in optimized
order.
|
T |
ArrayFieldVector.walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in optimized
order.
|
T |
SparseFieldVector.walkInOptimizedOrder(FieldVectorPreservingVisitor<T> visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in optimized
order.
|
double |
RealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
double |
AbstractRealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
double |
BlockRealMatrix.walkInOptimizedOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries using the fastest possible order.
|
double |
RealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
double |
AbstractRealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
double |
BlockRealMatrix.walkInOptimizedOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries using the fastest possible order.
|
double |
ArrayRealVector.walkInOptimizedOrder(RealVectorChangingVisitor visitor,
int start,
int end)
Visits (and possibly change) some entries of this vector in optimized
order.
|
double |
RealVector.walkInOptimizedOrder(RealVectorChangingVisitor visitor,
int start,
int end)
Visits (and possibly change) some entries of this vector in optimized
order.
|
double |
ArrayRealVector.walkInOptimizedOrder(RealVectorPreservingVisitor visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in optimized
order.
|
double |
RealVector.walkInOptimizedOrder(RealVectorPreservingVisitor visitor,
int start,
int end)
Visits (but does not alter) some entries of this vector in optimized
order.
|
T |
BlockFieldMatrix.walkInRowOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
T |
FieldMatrix.walkInRowOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
T |
Array2DRowFieldMatrix.walkInRowOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
T |
AbstractFieldMatrix.walkInRowOrder(FieldMatrixChangingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
T |
BlockFieldMatrix.walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
T |
FieldMatrix.walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
T |
Array2DRowFieldMatrix.walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
T |
AbstractFieldMatrix.walkInRowOrder(FieldMatrixPreservingVisitor<T> visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
double |
RealMatrix.walkInRowOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
double |
Array2DRowRealMatrix.walkInRowOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
double |
AbstractRealMatrix.walkInRowOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
double |
BlockRealMatrix.walkInRowOrder(RealMatrixChangingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (and possibly change) some matrix entries in row order.
|
double |
RealMatrix.walkInRowOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
double |
Array2DRowRealMatrix.walkInRowOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
double |
AbstractRealMatrix.walkInRowOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
double |
BlockRealMatrix.walkInRowOrder(RealMatrixPreservingVisitor visitor,
int startRow,
int endRow,
int startColumn,
int endColumn)
Visit (but don't change) some matrix entries in row order.
|
| Constructor and Description |
|---|
AbstractFieldMatrix(Field<T> field,
int rowDimension,
int columnDimension)
Create a new FieldMatrix
|
AbstractRealMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix with the supplied row and column dimensions.
|
Array2DRowFieldMatrix(Field<T> field,
int rowDimension,
int columnDimension)
Create a new
FieldMatrix<T> with the supplied row and column dimensions. |
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[] v)
Create a new (column)
FieldMatrix<T> using v as the
data for the unique column of the created matrix. |
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.
|
Array2DRowRealMatrix(int rowDimension,
int columnDimension)
Create a new RealMatrix with the supplied row and column dimensions.
|
ArrayFieldVector(Field<T> field,
T[] d,
int pos,
int size)
Construct a vector from part of a array.
|
ArrayFieldVector(Field<T> field,
T[] v1,
T[] v2)
Construct a vector by appending one vector to another vector.
|
ArrayFieldVector(T[] d)
Construct a vector from an array, copying the input array.
|
ArrayFieldVector(T[] d,
boolean copyArray)
Create a new ArrayFieldVector using the input array as the underlying
data array.
|
ArrayFieldVector(T[] d,
int pos,
int size)
Construct a vector from part of a array.
|
ArrayFieldVector(T[] v1,
T[] v2)
Construct a vector by appending one vector to another vector.
|
ArrayRealVector(double[] d,
int pos,
int size)
Construct a vector from part of a array.
|
ArrayRealVector(Double[] d,
int pos,
int size)
Construct a vector from part of an array.
|
BlockFieldMatrix(Field<T> field,
int rows,
int columns)
Create a new matrix with the supplied row and column dimensions.
|
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)
Create a new matrix with the supplied row and column dimensions.
|
BlockRealMatrix(int rows,
int columns,
double[][] blockData,
boolean copyArray)
Create a new dense matrix copying entries from block layout data.
|
DiagonalMatrix(int dimension)
Creates a matrix with the supplied dimension.
|
OpenMapRealMatrix(int rowDimension,
int columnDimension)
Build a sparse matrix with the supplied row and column dimensions.
|
RectangularCholeskyDecomposition(RealMatrix matrix)
Decompose a symmetric positive semidefinite matrix.
|
RectangularCholeskyDecomposition(RealMatrix matrix,
double small)
Decompose a symmetric positive semidefinite matrix.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DimensionMismatchException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
InsufficientDataException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
MathIllegalNumberException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
MultiDimensionMismatchException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NoBracketingException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NoDataException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonMonotonicSequenceException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NotANumberException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NotFiniteNumberException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NotPositiveException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NotStrictlyPositiveException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NumberIsTooLargeException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NumberIsTooSmallException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
OutOfRangeException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
ZeroException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
| Modifier and Type | Class and Description |
|---|---|
class |
InvalidRepresentationException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalStateException |
| Modifier and Type | Class and Description |
|---|---|
class |
NotARotationMatrixException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalStateException |
| Modifier and Type | Class and Description |
|---|---|
class |
IllConditionedOperatorException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
MatrixDimensionMismatchException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonPositiveDefiniteMatrixException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonPositiveDefiniteOperatorException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonSelfAdjointOperatorException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonSquareMatrixException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonSquareOperatorException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
NonSymmetricMatrixException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
class |
SingularMatrixException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalStateException |
class |
SingularOperatorException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
| Modifier and Type | Class and Description |
|---|---|
static class |
JacobianMatrices.MismatchedEquations
Deprecated.
Special exception for equations mismatch.
|
class |
UnknownParameterException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
| Modifier and Type | Method and Description |
|---|---|
void |
FirstOrderDifferentialEquations.computeDerivatives(double t,
double[] y,
double[] yDot)
Deprecated.
Get the current time derivative of the state vector.
|
default double[] |
SecondaryEquations.computeDerivatives(double t,
double[] primary,
double[] primaryDot,
double[] secondary)
Deprecated.
Compute the derivatives related to the secondary state parameters.
|
void |
SecondaryEquations.computeDerivatives(double t,
double[] primary,
double[] primaryDot,
double[] secondary,
double[] secondaryDot)
Deprecated.
Compute the derivatives related to the secondary state parameters.
|
double[][] |
MainStateJacobianProvider.computeMainStateJacobian(double t,
double[] y,
double[] yDot)
Deprecated.
Compute the jacobian matrix of ODE with respect to main state.
|
default double[] |
ParameterJacobianProvider.computeParameterJacobian(double t,
double[] y,
double[] yDot,
String paramName)
Deprecated.
Compute the Jacobian matrix of ODE with respect to one parameter.
|
void |
ParameterJacobianProvider.computeParameterJacobian(double t,
double[] y,
double[] yDot,
String paramName,
double[] dFdP)
Deprecated.
Compute the Jacobian matrix of ODE with respect to one parameter.
|
void |
JacobianMatrices.registerVariationalEquations(ExpandableODE expandable)
Deprecated.
Register the variational equations for the Jacobians matrices to the expandable set.
|
void |
JacobianMatrices.setInitialMainStateJacobian(double[][] dYdY0)
Deprecated.
Set the initial value of the Jacobian matrix with respect to state.
|
void |
JacobianMatrices.setInitialParameterJacobian(String pName,
double[] dYdP)
Deprecated.
Set the initial value of a column of the Jacobian matrix with respect to one parameter.
|
void |
JacobianMatrices.setParameterStep(String parameter,
double hP)
Deprecated.
Set the step associated to a parameter in order to compute by finite
difference the Jacobian matrix.
|
| Constructor and Description |
|---|
JacobianMatrices(OrdinaryDifferentialEquation fode,
double[] hY,
String... parameters)
Deprecated.
Simple constructor for a secondary equations set computing Jacobian matrices.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ModelSpecificationException
Deprecated.
as of 1.0, this exception is replaced by
MathIllegalArgumentException |
| Modifier and Type | Class and Description |
|---|---|
static class |
VariationalEquation.MismatchedEquations
Special exception for equations mismatch.
|
| Modifier and Type | Method and Description |
|---|---|
protected FieldODEStateAndDerivative<T> |
AbstractFieldIntegrator.acceptStep(AbstractFieldODEStateInterpolator<T> interpolator,
T tEnd)
Accept a step, triggering events and step handlers.
|
protected ODEStateAndDerivative |
AbstractIntegrator.acceptStep(AbstractODEStateInterpolator interpolator,
double tEnd)
Accept a step, triggering events and step handlers.
|
void |
DenseOutputModel.append(DenseOutputModel model)
Append another model at the end of the instance.
|
void |
FieldDenseOutputModel.append(FieldDenseOutputModel<T> model)
Append another model at the end of the instance.
|
void |
AbstractParameterizable.complainIfNotSupported(String name)
Check if a parameter is supported and throw an IllegalArgumentException if not.
|
double[] |
AbstractIntegrator.computeDerivatives(double t,
double[] y)
Compute the derivatives and check the number of evaluations.
|
double[] |
ExpandableODE.computeDerivatives(double t,
double[] y)
Get the current time derivative of the complete state vector.
|
double[] |
SecondaryODE.computeDerivatives(double t,
double[] primary,
double[] primaryDot,
double[] secondary)
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[] |
FieldSecondaryODE.computeDerivatives(T t,
T[] primary,
T[] primaryDot,
T[] secondary)
Compute the derivatives related to the secondary state parameters.
|
double[][] |
ODEJacobiansProvider.computeMainStateJacobian(double t,
double[] y,
double[] yDot)
Compute the Jacobian matrix of ODE with respect to state.
|
double[] |
NamedParameterJacobianProvider.computeParameterJacobian(double t,
double[] y,
double[] yDot,
String paramName)
Compute the Jacobian matrix of ODE with respect to one parameter.
|
default double[] |
ODEJacobiansProvider.computeParameterJacobian(double t,
double[] y,
double[] yDot,
String paramName)
Compute the Jacobian matrix of ODE with respect to one parameter.
|
double[] |
EquationsMapper.extractEquationData(int index,
double[] complete)
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 |
ParametersController.getParameter(String name)
Get parameter value from its name.
|
void |
EquationsMapper.insertEquationData(int index,
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.
|
ODEStateAndDerivative |
ODEIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
FieldODEStateAndDerivative<T> |
FieldODEIntegrator.integrate(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T finalTime)
Integrate the differential equations up to the given time.
|
default double |
ODEIntegrator.integrate(OrdinaryDifferentialEquation equations,
double t0,
double[] y0,
double t,
double[] y)
Deprecated.
as of 1.0, replaced with
ODEIntegrator.integrate(ExpandableODE, ODEState, double) |
default ODEStateAndDerivative |
ODEIntegrator.integrate(OrdinaryDifferentialEquation equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
ODEStateAndDerivative |
EquationsMapper.mapStateAndDerivative(double t,
double[] y,
double[] yDot)
Map flat arrays to a state and derivative.
|
FieldODEStateAndDerivative<T> |
FieldEquationsMapper.mapStateAndDerivative(T t,
T[] y,
T[] yDot)
Map flat arrays to a state and derivative.
|
protected void |
AbstractFieldIntegrator.sanityChecks(FieldODEState<T> initialState,
T t)
Check the integration span.
|
protected void |
AbstractIntegrator.sanityChecks(ODEState initialState,
double t)
Check the integration span.
|
void |
VariationalEquation.setInitialMainStateJacobian(double[][] dYdY0)
Set the initial value of the Jacobian matrix with respect to state.
|
void |
VariationalEquation.setInitialParameterJacobian(String pName,
double[] dYdP)
Set the initial value of a column of the Jacobian matrix with respect to one parameter.
|
void |
ParametersController.setParameter(String name,
double value)
Set the value for a given parameter.
|
protected void |
MultistepIntegrator.start(ExpandableODE equations,
ODEState initialState,
double finalTime)
Start the integration.
|
protected void |
MultistepFieldIntegrator.start(FieldExpandableODE<T> equations,
FieldODEState<T> initialState,
T t)
Start the integration.
|
| Constructor and Description |
|---|
MultistepFieldIntegrator(Field<T> field,
String name,
int nSteps,
int order,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build a multistep integrator with the given stepsize bounds.
|
MultistepIntegrator(String name,
int nSteps,
int order,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build a multistep integrator with the given stepsize bounds.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
FieldEventState.evaluateStep(FieldODEStateInterpolator<T> interpolator)
Evaluate the impact of the proposed step on the event handler.
|
boolean |
EventState.evaluateStep(ODEStateInterpolator interpolator)
Evaluate the impact of the proposed step on the event handler.
|
| Modifier and Type | Method and Description |
|---|---|
protected double |
AdaptiveStepsizeIntegrator.filterStep(double h,
boolean forward,
boolean acceptSmall)
Filter the integration step.
|
protected T |
AdaptiveStepsizeFieldIntegrator.filterStep(T h,
boolean forward,
boolean acceptSmall)
Filter the integration step.
|
double |
AdaptiveStepsizeIntegrator.initializeStep(boolean forward,
int order,
double[] scale,
ODEStateAndDerivative state0,
EquationsMapper mapper)
Initialize the integration step.
|
T |
AdaptiveStepsizeFieldIntegrator.initializeStep(boolean forward,
int order,
T[] scale,
FieldODEStateAndDerivative<T> state0,
FieldEquationsMapper<T> mapper)
Initialize the integration step.
|
ODEStateAndDerivative |
AdamsMoultonIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
ODEStateAndDerivative |
EmbeddedRungeKuttaIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
abstract ODEStateAndDerivative |
AdamsIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
ODEStateAndDerivative |
RungeKuttaIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
ODEStateAndDerivative |
AdamsBashforthIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double finalTime)
Integrate the differential equations up to the given time.
|
ODEStateAndDerivative |
GraggBulirschStoerIntegrator.integrate(ExpandableODE equations,
ODEState initialState,
double 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.
|
FieldODEStateAndDerivative<T> |
EmbeddedRungeKuttaFieldIntegrator.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.
|
FieldODEStateAndDerivative<T> |
RungeKuttaFieldIntegrator.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.
|
protected void |
AdaptiveStepsizeFieldIntegrator.sanityChecks(FieldODEState<T> initialState,
T t)
Check the integration span.
|
protected void |
AdaptiveStepsizeIntegrator.sanityChecks(ODEState initialState,
double t)
Check the integration span.
|
| Constructor and Description |
|---|
AdamsBashforthFieldIntegrator(Field<T> field,
int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Bashforth integrator with the given order and step control parameters.
|
AdamsBashforthIntegrator(int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Bashforth integrator with the given order and step control parameters.
|
AdamsFieldIntegrator(Field<T> field,
String name,
int nSteps,
int order,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams integrator with the given order and step control parameters.
|
AdamsIntegrator(String name,
int nSteps,
int order,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams integrator with the given order and step control parameters.
|
AdamsMoultonFieldIntegrator(Field<T> field,
int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Moulton integrator with the given order and error control parameters.
|
AdamsMoultonIntegrator(int nSteps,
double minStep,
double maxStep,
double scalAbsoluteTolerance,
double scalRelativeTolerance)
Build an Adams-Moulton integrator with the given order and error control parameters.
|
| Constructor and Description |
|---|
MultiStartMultivariateOptimizer(MultivariateOptimizer optimizer,
int starts,
RandomVectorGenerator generator)
Create a multi-start optimizer from a single-start optimizer.
|
| Modifier and Type | Method and Description |
|---|---|
PointValuePair |
CMAESOptimizer.optimize(OptimizationData... optData)
Stores data and performs the optimization.
|
| Constructor and Description |
|---|
PopulationSize(int size) |
Sigma(double[] s) |
| Modifier and Type | Method and Description |
|---|---|
String |
RandomDataGenerator.nextHexString(int len)
Generates a random string of hex characters of length
len. |
long |
RandomDataGenerator.nextLong(long lower,
long upper)
Returns a uniformly distributed random long integer between lower and upper (inclusive).
|
int[] |
RandomDataGenerator.nextPermutation(int n,
int k)
Generates an integer array of length
k whose entries are selected
randomly, without repetition, from the integers 0, ..., n - 1
(inclusive). |
Object[] |
RandomDataGenerator.nextSample(Collection<?> c,
int k)
Returns an array of
k objects selected randomly from the
Collection c. |
double[] |
RandomDataGenerator.nextSample(double[] a,
int k)
Returns an array of
k double values selected randomly from the
double array a. |
double[] |
HaltonSequenceGenerator.skipTo(int index)
Skip to the i-th point in the Halton sequence.
|
double[] |
SobolSequenceGenerator.skipTo(int index)
Skip to the i-th point in the Sobol sequence.
|
| Constructor and Description |
|---|
HaltonSequenceGenerator(int dimension)
Construct a new Halton sequence generator for the given space dimension.
|
HaltonSequenceGenerator(int dimension,
int[] bases,
int[] weights)
Construct a new Halton sequence generator with the given base numbers and weights for each dimension.
|
SobolSequenceGenerator(int dimension)
Construct a new Sobol sequence generator for the given space dimension.
|
SobolSequenceGenerator(int dimension,
InputStream is)
Construct a new Sobol sequence generator for the given space dimension with
direction vectors loaded from the given stream.
|
StableRandomGenerator(RandomGenerator generator,
double alpha,
double beta)
Create a new generator.
|
| Modifier and Type | Method and Description |
|---|---|
static double |
Gamma.logGamma1p(double x)
Returns the value of log Γ(1 + x) for -0.5 ≤ x ≤ 1.5.
|
double |
BesselJ.value(double x)
Returns the value of the constructed Bessel function of the first kind,
for the passed argument.
|
static double |
BesselJ.value(double order,
double x)
Returns the first Bessel function, \(J_{order}(x)\).
|
| Modifier and Type | Method and Description |
|---|---|
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.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.min(double... values)
Returns the minimum of the entries in the input array, or
Double.NaN if the array is empty. |
static double |
StatUtils.min(double[] values,
int begin,
int length)
Returns the minimum of the entries in the specified portion of the input array,
or
Double.NaN if the designated subarray is empty. |
static double[] |
StatUtils.mode(double... sample)
Returns the sample mode(s).
|
static double |
StatUtils.percentile(double[] values,
double p)
Returns an estimate of the
pth 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
pth 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.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.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. |
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. |
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 |
KendallsCorrelation.correlation(double[] xArray,
double[] yArray)
Computes the Kendall's Tau rank correlation coefficient between the two arrays.
|
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.
|
double |
StorelessCovariance.getCovariance(int xIndex,
int yIndex)
Get the covariance for an individual element of the covariance matrix.
|
RealMatrix |
StorelessCovariance.getCovarianceMatrix()
Returns the covariance matrix
|
double[][] |
StorelessCovariance.getData()
Return the covariance matrix as two-dimensional array.
|
void |
StorelessCovariance.increment(double[] data)
Increment the covariance matrix with one row of data.
|
| Constructor and Description |
|---|
Covariance(double[][] data)
Create a Covariance matrix from a rectangular array
whose columns represent covariates.
|
Covariance(double[][] data,
boolean biasCorrected)
Create a Covariance matrix from a rectangular array
whose columns represent covariates.
|
Covariance(RealMatrix matrix)
Create a covariance matrix from a matrix whose columns
represent covariates.
|
Covariance(RealMatrix matrix,
boolean biasCorrected)
Create a covariance matrix from a matrix whose columns
represent covariates.
|
SpearmansCorrelation(RankingAlgorithm rankingAlgorithm)
Create a SpearmansCorrelation with the given ranking algorithm.
|
SpearmansCorrelation(RealMatrix dataMatrix,
RankingAlgorithm rankingAlgorithm)
Create a SpearmansCorrelation with the given input data matrix
and ranking algorithm.
|
| Modifier and Type | Method and Description |
|---|---|
void |
MultivariateSummaryStatistics.addValue(double[] value)
Add an n-tuple to the data
|
double |
AbstractUnivariateStatistic.evaluate()
Returns the result of evaluating the statistic over the stored data.
|
default double |
UnivariateStatistic.evaluate(double[] values)
Returns the result of evaluating the statistic over the input array.
|
default 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.
|
double |
UnivariateStatistic.evaluate(double[] values,
int begin,
int length)
Returns the result of evaluating the statistic over the specified entries
in the input 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.
|
default double |
StorelessUnivariateStatistic.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.
|
default void |
StorelessUnivariateStatistic.incrementAll(double[] values)
Updates the internal state of the statistic to reflect addition of
all values in the values array.
|
default void |
StorelessUnivariateStatistic.incrementAll(double[] values,
int start,
int length)
Updates the internal state of the statistic to reflect addition of
the values in the designated portion of the values array.
|
void |
AbstractUnivariateStatistic.setData(double[] values,
int begin,
int length)
Set the data array.
|
void |
DescriptiveStatistics.setWindowSize(int windowSize)
WindowSize controls the number of values that contribute to the
reported statistics.
|
| Constructor and Description |
|---|
DescriptiveStatistics(int size)
Construct a DescriptiveStatistics instance with the specified window.
|
| Modifier and Type | Method and Description |
|---|---|
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 mean)
Returns the variance of the entries in the input array, using the
precomputed mean value.
|
double |
Variance.evaluate(double[] values,
double[] weights,
double mean)
Returns the weighted variance of the values in the input array, using
the precomputed weighted mean value.
|
double |
Variance.evaluate(double[] values,
double[] weights,
double mean,
int begin,
int length)
Returns the weighted variance of the entries in the specified portion of
the input array, using the precomputed weighted mean value.
|
double |
Mean.evaluate(double[] values,
double[] weights,
int begin,
int length)
Returns the weighted arithmetic mean of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
double |
Variance.evaluate(double[] values,
double[] weights,
int begin,
int length)
Returns the weighted variance of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
double |
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 |
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 |
SemiVariance.evaluate(double[] values,
double cutoff,
SemiVariance.Direction direction)
Returns the
SemiVariance of the designated values against the cutoff in the
given direction, using the current value of the biasCorrection instance property. |
double |
SemiVariance.evaluate(double[] values,
double cutoff,
SemiVariance.Direction direction,
boolean corrected,
int start,
int length)
Returns the
SemiVariance of the designated values against the cutoff
in the given direction with the provided bias correction. |
double |
Kurtosis.evaluate(double[] values,
int begin,
int length)
Returns the kurtosis of the entries in the specified portion of the
input array.
|
double |
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 |
GeometricMean.evaluate(double[] values,
int begin,
int length)
Returns the geometric mean of the entries in the specified portion
of the input array.
|
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 |
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 |
Skewness.evaluate(double[] values,
int begin,
int length)
Returns the Skewness of the entries in the specified portion of the
input array.
|
double |
Variance.evaluate(double[] values,
int begin,
int length)
Returns the variance of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
double |
SemiVariance.evaluate(double[] values,
SemiVariance.Direction direction)
This method calculates
SemiVariance for the entire array against the mean,
using the current value of the biasCorrection instance property. |
| Modifier and Type | Method and Description |
|---|---|
double |
Percentile.evaluate(double p)
Returns the result of evaluating the statistic over the stored data.
|
double |
Percentile.evaluate(double[] values,
double p)
Returns an estimate of the
pth percentile of the values
in the values array. |
double |
Percentile.evaluate(double[] values,
int start,
int length)
Returns an estimate of the
quantileth percentile of the
designated 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 |
Median.evaluate(double[] values,
int begin,
int length)
Returns the result of evaluating the statistic over the specified entries
in the input array.
|
double |
Percentile.evaluate(double[] values,
int begin,
int length,
double p)
Returns an estimate of the
pth percentile of the values
in the values array, starting with the element in (0-based)
position begin in the array and including length
values. |
double |
RandomPercentile.evaluate(double percentile,
double[] values,
int begin,
int length)
Returns an estimate of the given percentile, computed using the designated
array segment as input data.
|
void |
Percentile.setData(double[] values,
int begin,
int length)
Set the data array.
|
void |
Percentile.setQuantile(double p)
Sets the value of the quantile field (determines what percentile is
computed when evaluate() is called with no quantile argument).
|
| Constructor and Description |
|---|
Percentile(double quantile)
Constructs a Percentile with the specific quantile value and the following
default method type:
Percentile.EstimationType.LEGACY
default NaN strategy: NaNStrategy.REMOVED
a Kth Selector : KthSelector
|
Percentile(double quantile,
Percentile.EstimationType estimationType,
NaNStrategy nanStrategy,
KthSelector kthSelector)
Constructs a Percentile with the specific quantile value,
Percentile.EstimationType, NaNStrategy and KthSelector. |
| Modifier and Type | Method and Description |
|---|---|
double |
Sum.evaluate(double[] values,
double[] weights,
int begin,
int length)
The weighted sum of the entries in the specified portion of
the input array, or 0 if the designated subarray
is empty.
|
double |
Product.evaluate(double[] values,
double[] weights,
int begin,
int length)
Returns the weighted product of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
double |
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. |
double |
SumOfLogs.evaluate(double[] values,
int begin,
int length)
Returns the sum of the natural logs of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
double |
Sum.evaluate(double[] values,
int begin,
int length)
The sum of the entries in the specified portion of the input array,
or 0 if the designated subarray is empty.
|
double |
Product.evaluate(double[] values,
int begin,
int length)
Returns the product of the entries in the specified portion of
the input array, or
Double.NaN if the designated subarray
is empty. |
| Modifier and Type | Method and Description |
|---|---|
void |
VectorialCovariance.increment(double[] v)
Add a new vector to the sample.
|
| 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)
Fit a mixture model to the data supplied to the constructor.
|
void |
MultivariateNormalMixtureExpectationMaximization.fit(MixtureMultivariateNormalDistribution initialMixture,
int maxIterations,
double threshold)
Fit a mixture model to the data supplied to the constructor.
|
double |
EmpiricalDistribution.inverseCumulativeProbability(double p)
Computes the quantile function of this distribution.
|
void |
EmpiricalDistribution.load(URL url)
Computes the empirical distribution using data read from a URL.
|
| Constructor and Description |
|---|
MultivariateNormalMixtureExpectationMaximization(double[][] data)
Creates an object to fit a multivariate normal mixture model to data.
|
| 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<StreamingStatistics> categoryData,
boolean allowOneElementData)
Computes the ANOVA P-value for a collection of
StreamingStatistics. |
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 |
InferenceTestUtils.chiSquare(double[] expected,
long[] observed) |
double |
ChiSquareTest.chiSquare(double[] expected,
long[] observed)
|
static double |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.g(double[] expected,
long[] observed) |
double |
GTest.g(double[] expected,
long[] observed)
|
static double |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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 |
InferenceTestUtils.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.
|
double |
TTest.homoscedasticT(double[] sample1,
double[] sample2)
Computes a 2-sample t statistic, under the hypothesis of equal
subpopulation variances.
|
static double |
InferenceTestUtils.homoscedasticT(double[] sample1,
double[] sample2) |
double |
TTest.homoscedasticT(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
Computes a 2-sample t statistic, comparing the means of the datasets
described by two
StatisticalSummary instances, under the
assumption of equal subpopulation variances. |
static double |
InferenceTestUtils.homoscedasticT(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2) |
double |
TTest.homoscedasticTTest(double[] sample1,
double[] sample2)
Returns the observed significance level, or
p-value, associated with a two-sample, two-tailed t-test
comparing the means of the input arrays, under the assumption that
the two samples are drawn from subpopulations with equal variances.
|
static double |
InferenceTestUtils.homoscedasticTTest(double[] sample1,
double[] sample2) |
boolean |
TTest.homoscedasticTTest(double[] sample1,
double[] sample2,
double alpha)
Performs a
two-sided t-test evaluating the null hypothesis that
sample1
and sample2 are drawn from populations with the same mean,
with significance level alpha, assuming that the
subpopulation variances are equal. |
static boolean |
InferenceTestUtils.homoscedasticTTest(double[] sample1,
double[] sample2,
double alpha) |
protected double |
TTest.homoscedasticTTest(double m1,
double m2,
double v1,
double v2,
double n1,
double n2)
Computes p-value for 2-sided, 2-sample t-test, under the assumption
of equal subpopulation variances.
|
double |
TTest.homoscedasticTTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
Returns the observed significance level, or
p-value, associated with a two-sample, two-tailed t-test
comparing the means of the datasets described by two StatisticalSummary
instances, under the hypothesis of equal subpopulation variances.
|
static double |
InferenceTestUtils.homoscedasticTTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2) |
static double |
InferenceTestUtils.kolmogorovSmirnovStatistic(double[] x,
double[] y) |
static double |
InferenceTestUtils.kolmogorovSmirnovStatistic(RealDistribution dist,
double[] data) |
static double |
InferenceTestUtils.kolmogorovSmirnovTest(double[] x,
double[] y) |
static double |
InferenceTestUtils.kolmogorovSmirnovTest(double[] x,
double[] y,
boolean strict) |
static double |
InferenceTestUtils.kolmogorovSmirnovTest(RealDistribution dist,
double[] data) |
static double |
InferenceTestUtils.kolmogorovSmirnovTest(RealDistribution dist,
double[] data,
boolean strict) |
static boolean |
InferenceTestUtils.kolmogorovSmirnovTest(RealDistribution dist,
double[] data,
double alpha) |
double |
MannWhitneyUTest.mannWhitneyU(double[] x,
double[] y)
Computes the Mann-Whitney
U statistic comparing mean for two independent samples possibly of
different length.
|
double |
MannWhitneyUTest.mannWhitneyUTest(double[] x,
double[] y)
Returns the asymptotic observed significance level, or
p-value, associated with a
Mann-Whitney
U statistic comparing mean for two independent samples.
|
static double |
InferenceTestUtils.oneWayAnovaFValue(Collection<double[]> categoryData) |
static double |
InferenceTestUtils.oneWayAnovaPValue(Collection<double[]> categoryData) |
static boolean |
InferenceTestUtils.oneWayAnovaTest(Collection<double[]> categoryData,
double alpha) |
double |
TTest.pairedT(double[] sample1,
double[] sample2)
Computes a paired, 2-sample t-statistic based on the data in the input
arrays.
|
static double |
InferenceTestUtils.pairedT(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 double |
InferenceTestUtils.pairedTTest(double[] sample1,
double[] sample2) |
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 boolean |
InferenceTestUtils.pairedTTest(double[] sample1,
double[] sample2,
double alpha) |
static double |
InferenceTestUtils.rootLogLikelihoodRatio(long k11,
long k12,
long k21,
long k22) |
double |
TTest.t(double[] sample1,
double[] sample2)
Computes a 2-sample t statistic, without the hypothesis of equal
subpopulation variances.
|
static double |
InferenceTestUtils.t(double[] sample1,
double[] sample2) |
double |
TTest.t(double mu,
double[] observed)
Computes a
t statistic given observed values and a comparison constant.
|
static double |
InferenceTestUtils.t(double mu,
double[] observed) |
double |
TTest.t(double mu,
StatisticalSummary sampleStats)
|
static double |
InferenceTestUtils.t(double mu,
StatisticalSummary sampleStats) |
double |
TTest.t(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
Computes a 2-sample t statistic , comparing the means of the datasets
described by two
StatisticalSummary instances, without the
assumption of equal subpopulation variances. |
static double |
InferenceTestUtils.t(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2) |
double |
TTest.tTest(double[] sample1,
double[] sample2)
Returns the observed significance level, or
p-value, associated with a two-sample, two-tailed t-test
comparing the means of the input arrays.
|
static double |
InferenceTestUtils.tTest(double[] sample1,
double[] sample2) |
boolean |
TTest.tTest(double[] sample1,
double[] sample2,
double alpha)
Performs a
two-sided t-test evaluating the null hypothesis that
sample1
and sample2 are drawn from populations with the same mean,
with significance level alpha. |
static boolean |
InferenceTestUtils.tTest(double[] sample1,
double[] sample2,
double alpha) |
double |
TTest.tTest(double mu,
double[] sample)
Returns the observed significance level, or
p-value, associated with a one-sample, two-tailed t-test
comparing the mean of the input array with the constant
mu. |
static double |
InferenceTestUtils.tTest(double mu,
double[] sample) |
boolean |
TTest.tTest(double mu,
double[] sample,
double alpha)
Performs a
two-sided t-test evaluating the null hypothesis that the mean of the population from
which
sample is drawn equals mu. |
static boolean |
InferenceTestUtils.tTest(double mu,
double[] sample,
double alpha) |
protected double |
TTest.tTest(double m,
double mu,
double v,
double n)
Computes p-value for 2-sided, 1-sample t-test.
|
protected double |
TTest.tTest(double m1,
double m2,
double v1,
double v2,
double n1,
double n2)
Computes p-value for 2-sided, 2-sample t-test.
|
double |
TTest.tTest(double mu,
StatisticalSummary sampleStats)
Returns the observed significance level, or
p-value, associated with a one-sample, two-tailed t-test
comparing the mean of the dataset described by
sampleStats
with the constant mu. |
static double |
InferenceTestUtils.tTest(double mu,
StatisticalSummary sampleStats) |
boolean |
TTest.tTest(double mu,
StatisticalSummary sampleStats,
double alpha)
Performs a
two-sided t-test evaluating the null hypothesis that the mean of the
population from which the dataset described by
stats is
drawn equals mu. |
static boolean |
InferenceTestUtils.tTest(double mu,
StatisticalSummary sampleStats,
double alpha) |
double |
TTest.tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
Returns the observed significance level, or
p-value, associated with a two-sample, two-tailed t-test
comparing the means of the datasets described by two StatisticalSummary
instances.
|
static double |
InferenceTestUtils.tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2) |
boolean |
TTest.tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2,
double alpha)
Performs a
two-sided t-test evaluating the null hypothesis that
sampleStats1 and sampleStats2 describe
datasets drawn from populations with the same mean, with significance
level alpha. |
static boolean |
InferenceTestUtils.tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2,
double alpha) |
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 ConfidenceInterval |
BinomialProportion.getAgrestiCoullInterval(int numberOfTrials,
double probabilityOfSuccess,
double confidenceLevel)
Create an Agresti-Coull binomial confidence interval for the true
probability of success of an unknown binomial distribution with
the given observed number of trials, probability of success and
confidence level.
|
static ConfidenceInterval |
BinomialProportion.getClopperPearsonInterval(int numberOfTrials,
double probabilityOfSuccess,
double confidenceLevel)
Create a Clopper-Pearson binomial confidence interval for the true
probability of success of an unknown binomial distribution with
the given observed number of trials, probability of success and
confidence level.
|
static ConfidenceInterval |
BinomialProportion.getNormalApproximationInterval(int numberOfTrials,
double probabilityOfSuccess,
double confidenceLevel)
Create a binomial confidence interval using normal approximation
for the true probability of success of an unknown binomial distribution
with the given observed number of trials, probability of success and
confidence level.
|
static ConfidenceInterval |
BinomialProportion.getWilsonScoreInterval(int numberOfTrials,
double probabilityOfSuccess,
double confidenceLevel)
Create an Wilson score binomial confidence interval for the true
probability of success of an unknown binomial distribution with
the given observed number of trials, probability of success and
confidence level.
|
| Modifier and Type | Method and Description |
|---|---|
void |
SimpleRegression.addData(double[][] data)
Adds the observations represented by the elements in
data. |
void |
MillerUpdatingRegression.addObservation(double[] x,
double y)
Adds an observation to the regression model.
|
void |
UpdatingMultipleLinearRegression.addObservation(double[] x,
double y)
Adds one observation to the regression model.
|
void |
SimpleRegression.addObservation(double[] x,
double y)
Adds one observation to the regression model.
|
void |
MillerUpdatingRegression.addObservations(double[][] x,
double[] y)
Adds multiple observations to the model.
|
void |
UpdatingMultipleLinearRegression.addObservations(double[][] x,
double[] y)
Adds a series of observations to the regression model.
|
void |
SimpleRegression.addObservations(double[][] x,
double[] y)
Adds a series of observations to the regression model.
|
double |
RegressionResults.getCovarianceOfParameters(int i,
int j)
Returns the covariance between regression parameters i and j.
|
double |
RegressionResults.getParameterEstimate(int index)
Returns the parameter estimate for the regressor at the given index.
|
double |
SimpleRegression.getSlopeConfidenceInterval()
Returns the half-width of a 95% confidence interval for the slope
estimate.
|
double |
SimpleRegression.getSlopeConfidenceInterval(double alpha)
Returns the half-width of a (100-100*alpha)% confidence interval for
the slope estimate.
|
double |
RegressionResults.getStdErrorOfEstimate(int index)
Returns the standard
error of the parameter estimate at index,
usually denoted s(bindex).
|
void |
OLSMultipleLinearRegression.newSampleData(double[] y,
double[][] x)
Loads model x and y sample data, overriding any previous sample.
|
RegressionResults |
MillerUpdatingRegression.regress()
Conducts a regression on the data in the model, using all regressors.
|
RegressionResults |
UpdatingMultipleLinearRegression.regress()
Performs a regression on data present in buffers and outputs a RegressionResults object
|
RegressionResults |
SimpleRegression.regress()
Performs a regression on data present in buffers and outputs a RegressionResults object.
|
RegressionResults |
MillerUpdatingRegression.regress(int numberOfRegressors)
Conducts a regression on the data in the model, using a subset of regressors.
|
RegressionResults |
MillerUpdatingRegression.regress(int[] variablesToInclude)
Conducts a regression on the data in the model, using regressors in array
Calling this method will change the internal order of the regressors
and care is required in interpreting the hatmatrix.
|
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.
|
| Constructor and Description |
|---|
MillerUpdatingRegression(int numberOfVariables,
boolean includeConstant)
Primary constructor for the MillerUpdatingRegression.
|
MillerUpdatingRegression(int numberOfVariables,
boolean includeConstant,
double errorTolerance)
This is the augmented constructor for the MillerUpdatingRegression class.
|
| 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. |
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.
|
| Modifier and Type | Method and Description |
|---|---|
static long |
CombinatoricsUtils.binomialCoefficient(int n,
int k)
Returns an exact representation of the Binomial
Coefficient, "
n choose k", the number of
k-element subsets that can be selected from an
n-element set. |
static double |
CombinatoricsUtils.binomialCoefficientDouble(int n,
int k)
Returns a
double representation of the Binomial
Coefficient, "n choose k", the number of
k-element subsets that can be selected from an
n-element set. |
static double |
CombinatoricsUtils.binomialCoefficientLog(int n,
int k)
Returns the natural
log of the Binomial
Coefficient, "n choose k", the number of
k-element subsets that can be selected from an
n-element set. |
static void |
CombinatoricsUtils.checkBinomial(int n,
int k)
Check binomial preconditions.
|
protected void |
ResizableDoubleArray.checkContractExpand(double contraction,
double expansion)
Checks the expansion factor and the contraction criterion and raises
an exception if the contraction criterion is smaller than the
expansion criterion.
|
static void |
MathUtils.checkFinite(double x)
Check that the argument is a real number.
|
static void |
MathUtils.checkFinite(double[] val)
Check that all the elements are real numbers.
|
static void |
MathArrays.checkNonNegative(long[] in)
Check that all entries of the input array are >= 0.
|
static void |
MathArrays.checkNonNegative(long[][] in)
Check all entries of the input array are >= 0.
|
static void |
MathArrays.checkNotNaN(double[] in)
Check that no entry of the input array is
NaN. |
static void |
MathArrays.checkOrder(double[] val)
Check that the given array is sorted in strictly increasing order.
|
static void |
MathArrays.checkOrder(double[] val,
MathArrays.OrderDirection dir,
boolean strict)
Check that the given array is sorted.
|
static boolean |
MathArrays.checkOrder(double[] val,
MathArrays.OrderDirection dir,
boolean strict,
boolean abort)
Check that the given array is sorted.
|
static void |
MathArrays.checkPositive(double[] in)
Check that all entries of the input array are strictly positive.
|
static void |
MathArrays.checkRectangular(long[][] in)
Throws MathIllegalArgumentException if the input array is not rectangular.
|
static double[] |
MathArrays.convolve(double[] x,
double[] h)
Calculates the
convolution between two sequences.
|
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.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.
|
static long |
CombinatoricsUtils.factorial(int n)
Returns n!.
|
static double |
CombinatoricsUtils.factorialDouble(int n)
|
static double |
CombinatoricsUtils.factorialLog(int n)
Compute the natural logarithm of the factorial of
n. |
int |
MultidimensionalCounter.getCount(int... c)
Convert to unidimensional counter.
|
int[] |
MultidimensionalCounter.getCounts(int index)
Convert to multidimensional 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.
|
FieldTuple<T> |
FieldTuple.linearCombination(double[] a,
FieldTuple<T>[] b)
Compute a linear combination.
|
Tuple |
Tuple.linearCombination(double[] a,
Tuple[] b)
Compute a linear combination.
|
FieldTuple<T> |
FieldTuple.linearCombination(FieldTuple<T>[] a,
FieldTuple<T>[] b)
Compute a linear combination.
|
Tuple |
Tuple.linearCombination(Tuple[] a,
Tuple[] b)
Compute a linear combination.
|
static double[] |
MathArrays.normalizeArray(double[] values,
double normalizedSum)
Normalizes an array to make it sum to a specified value.
|
abstract int |
PivotingStrategy.pivotIndex(double[] work,
int begin,
int end)
Find pivot index of the array so that partition and Kth
element selection can be made
|
static BigInteger |
ArithmeticUtils.pow(BigInteger k,
BigInteger e)
Raise a BigInteger to a BigInteger power.
|
static BigInteger |
ArithmeticUtils.pow(BigInteger k,
int e)
Raise a BigInteger to an int power.
|
static BigInteger |
ArithmeticUtils.pow(BigInteger k,
long e)
Raise a BigInteger to a long power.
|
static int |
ArithmeticUtils.pow(int k,
int e)
Raise an int to an int power.
|
static long |
ArithmeticUtils.pow(long k,
int e)
Raise a long to an int power.
|
static float |
Precision.round(float x,
int scale,
int roundingMethod)
Rounds the given value to the specified number of decimal places.
|
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.
|
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.
|
static long |
CombinatoricsUtils.stirlingS2(int n,
int k)
Returns the
Stirling number of the second kind, "
S(n,k)", the number of
ways of partitioning an n-element set into k non-empty
subsets. |
static boolean |
MathArrays.verifyValues(double[] values,
double[] weights,
int begin,
int length)
This method is used
to verify that the begin and length parameters designate a subarray of positive length
and the weights are all non-negative, non-NaN, finite, and not all zero.
|
static boolean |
MathArrays.verifyValues(double[] values,
double[] weights,
int begin,
int length,
boolean allowEmpty)
This method is used
to verify that the begin and length parameters designate a subarray of positive length
and the weights are all non-negative, non-NaN, finite, and not all zero.
|
static boolean |
MathArrays.verifyValues(double[] values,
int begin,
int length)
This method is used
to verify that the input parameters designate a subarray of positive length.
|
static boolean |
MathArrays.verifyValues(double[] values,
int begin,
int length,
boolean allowEmpty)
This method is used
to verify that the input parameters designate a subarray of positive length.
|
| Constructor and Description |
|---|
MultidimensionalCounter(int... size)
Create a counter.
|
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.
|
Copyright © 2016–2017 Hipparchus.org. All rights reserved.