Fix some javadoc issues.
This commit is contained in:
Ray DeCampo
parent
cdf22ce631
commit
53ec46ba27
|
|
@ -42,7 +42,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* corresponding y value.</li>
|
||||
* <li>Adjacent polynomials are equal through two derivatives at the knot points (i.e., adjacent polynomials
|
||||
* "match up" at the knot points, as do their first and second derivatives).</li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
* <p>
|
||||
* The cubic spline interpolation algorithm implemented is as described in R.L. Burden, J.D. Faires,
|
||||
* <u>Numerical Analysis</u>, 4th Ed., 1989, PWS-Kent, ISBN 0-53491-585-X, pp 126-131.
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ import org.apache.commons.numbers.core.Precision;
|
|||
/**
|
||||
* This class implements <a href="http://mathworld.wolfram.com/Quaternion.html">
|
||||
* quaternions</a> (Hamilton's hypercomplex numbers).
|
||||
* <br/>
|
||||
* <br>
|
||||
* Instance of this class are guaranteed to be immutable.
|
||||
*
|
||||
* @since 3.1
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ public class RootsOfUnity implements Serializable {
|
|||
* <ul>
|
||||
* <li>{@code abs(n)} is always the number of roots of unity.</li>
|
||||
* <li>If {@code n > 0}, then the roots are stored in counter-clockwise order.</li>
|
||||
* <li>If {@code n < 0}, then the roots are stored in clockwise order.</p>
|
||||
* <li>If {@code n < 0}, then the roots are stored in clockwise order.
|
||||
* </ul>
|
||||
*
|
||||
* @param n the (signed) number of roots of unity to be computed
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* algebraic operation</li>
|
||||
* <li>Comply with IEEE 854-1987 as much as possible.
|
||||
* (See IEEE 854-1987 notes below)</li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Trade offs:
|
||||
* <ol>
|
||||
|
|
@ -48,15 +48,15 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <li>Digits are bigger, so rounding is a greater loss. So, if you
|
||||
* really need 12 decimal digits, better use 4 base 10000 digits
|
||||
* there can be one partially filled.</li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Numbers are represented in the following form:
|
||||
* <pre>
|
||||
* n = sign × mant × (radix)<sup>exp</sup>;</p>
|
||||
* n = sign × mant × (radix)<sup>exp</sup>;
|
||||
* </pre>
|
||||
* where sign is ±1, mantissa represents a fractional number between
|
||||
* zero and one. mant[0] is the least significant digit.
|
||||
* exp is in the range of -32767 to 32768</p>
|
||||
* exp is in the range of -32767 to 32768
|
||||
*
|
||||
* <p>IEEE 854-1987 Notes and differences</p>
|
||||
*
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@
|
|||
* algebraic operation</li>
|
||||
* <li>Comply with IEEE 854-1987 as much as possible.
|
||||
* (See IEEE 854-1987 notes below)</li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Trade offs:
|
||||
* <ol>
|
||||
|
|
@ -40,7 +40,7 @@
|
|||
* <li>Digits are bigger, so rounding is a greater loss. So, if you
|
||||
* really need 12 decimal digits, better use 4 base 10000 digits
|
||||
* there can be one partially filled.</li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
*
|
||||
* <p>Numbers are represented in the following form:
|
||||
* <pre>
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* <li>Generate a uniformly distributed value in (0,1) </li>
|
||||
* <li>Select the subinterval to which the value belongs.
|
||||
* <li>Generate a random Gaussian value with mean = mean of the associated
|
||||
* bin and std dev = std dev of associated bin.</li></ol></p>
|
||||
* bin and std dev = std dev of associated bin.</li></ol>
|
||||
*
|
||||
* <p>EmpiricalDistribution implements the {@link RealDistribution} interface
|
||||
* as follows. Given x within the range of values in the dataset, let B
|
||||
|
|
@ -94,7 +94,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* by 10. </li>
|
||||
*<li>The input file <i>must</i> be a plain text file containing one valid numeric
|
||||
* entry per line.</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
*/
|
||||
public class EmpiricalDistribution extends AbstractRealDistribution {
|
||||
|
|
@ -434,7 +434,7 @@ public class EmpiricalDistribution extends AbstractRealDistribution {
|
|||
|
||||
/**
|
||||
* <p>Returns a fresh copy of the array of upper bounds for the bins.
|
||||
* Bins are: <br/>
|
||||
* Bins are: <br>
|
||||
* [min,upperBounds[0]],(upperBounds[0],upperBounds[1]],...,
|
||||
* (upperBounds[binCount-2], upperBounds[binCount-1] = max].</p>
|
||||
*
|
||||
|
|
@ -508,7 +508,7 @@ public class EmpiricalDistribution extends AbstractRealDistribution {
|
|||
* <li>Compute K(B) = the mass of B with respect to the within-bin kernel (i.e., the
|
||||
* integral of the kernel density over B).</li>
|
||||
* <li>Return k(x) * P(B) / K(B), where k is the within-bin kernel density
|
||||
* and P(B) is the mass of B.</li></ol></p>
|
||||
* and P(B) is the mass of B.</li></ol>
|
||||
* @since 3.1
|
||||
*/
|
||||
@Override
|
||||
|
|
@ -569,16 +569,16 @@ public class EmpiricalDistribution extends AbstractRealDistribution {
|
|||
* <li>Find the smallest i such that the sum of the masses of the bins
|
||||
* through i is at least p.</li>
|
||||
* <li>
|
||||
* Let K be the within-bin kernel distribution for bin i.</br>
|
||||
* Let K(B) be the mass of B under K. <br/>
|
||||
* Let K be the within-bin kernel distribution for bin i.<br>
|
||||
* Let K(B) be the mass of B under K. <br>
|
||||
* Let K(B-) be K evaluated at the lower endpoint of B (the combined
|
||||
* mass of the bins below B under K).<br/>
|
||||
* Let P(B) be the probability of bin i.<br/>
|
||||
* Let P(B-) be the sum of the bin masses below bin i. <br/>
|
||||
* Let pCrit = p - P(B-)<br/>
|
||||
* <li>Return the inverse of K evaluated at <br/>
|
||||
* mass of the bins below B under K).<br>
|
||||
* Let P(B) be the probability of bin i.<br>
|
||||
* Let P(B-) be the sum of the bin masses below bin i. <br>
|
||||
* Let pCrit = p - P(B-)<br>
|
||||
* <li>Return the inverse of K evaluated at <br>
|
||||
* K(B-) + pCrit * K(B) / P(B) </li>
|
||||
* </ol></p>
|
||||
* </ol>
|
||||
*
|
||||
* @since 3.1
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ import org.apache.commons.math4.util.Pair;
|
|||
* <p>Implementation of an integer-valued {@link EnumeratedDistribution}.</p>
|
||||
*
|
||||
* <p>Values with zero-probability are allowed but they do not extend the
|
||||
* support.<br/>
|
||||
* support.<br>
|
||||
* Duplicate values are allowed. Probabilities of duplicate values are combined
|
||||
* when computing cumulative probabilities and statistics.</p>
|
||||
*
|
||||
|
|
|
|||
|
|
@ -375,7 +375,6 @@ public class GammaDistribution extends AbstractRealDistribution {
|
|||
* </blockquote>
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*/
|
||||
@Override
|
||||
public RealDistribution.Sampler createSampler(final UniformRandomProvider rng) {
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@ import org.apache.commons.rng.sampling.distribution.InverseTransformParetoSample
|
|||
* <pre>
|
||||
* α * k^α / x^(α + 1)
|
||||
* </pre>
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li>{@code k} is the <em>scale</em> parameter: this is the minimum possible value of {@code X},</li>
|
||||
* <li>{@code α} is the <em>shape</em> parameter: this is the Pareto index</li>
|
||||
|
|
|
|||
|
|
@ -40,14 +40,14 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* </p>
|
||||
* <p>
|
||||
* For a random variable {@code X} whose values are distributed according to this
|
||||
* distribution, the probability mass function is given by<br/>
|
||||
* {@code P(X = k) = C(k + r - 1, r - 1) * p^r * (1 - p)^k,}<br/>
|
||||
* distribution, the probability mass function is given by<br>
|
||||
* {@code P(X = k) = C(k + r - 1, r - 1) * p^r * (1 - p)^k,}<br>
|
||||
* where {@code r} is the number of successes, {@code p} is the probability of
|
||||
* success, and {@code X} is the total number of failures. {@code C(n, k)} is
|
||||
* the binomial coefficient ({@code n} choose {@code k}). The mean and variance
|
||||
* of {@code X} are<br/>
|
||||
* {@code E(X) = (1 - p) * r / p, var(X) = (1 - p) * r / p^2.}<br/>
|
||||
* Finally, the cumulative distribution function is given by<br/>
|
||||
* of {@code X} are<br>
|
||||
* {@code E(X) = (1 - p) * r / p, var(X) = (1 - p) * r / p^2.}<br>
|
||||
* Finally, the cumulative distribution function is given by<br>
|
||||
* {@code P(X <= k) = I(p, r, k + 1)},
|
||||
* where I is the regularized incomplete Beta function.
|
||||
* </p>
|
||||
|
|
|
|||
|
|
@ -35,7 +35,6 @@ import org.apache.commons.rng.sampling.distribution.RejectionInversionZipfSample
|
|||
* </pre>
|
||||
* {@code H(N,s)} is the normalizing constant
|
||||
* which corresponds to the generalized harmonic number of order N of s.
|
||||
* <p>
|
||||
* <ul>
|
||||
* <li>{@code N} is the number of elements</li>
|
||||
* <li>{@code s} is the exponent</li>
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
import org.apache.commons.math4.util.Pair;
|
||||
|
||||
/**
|
||||
* Expectation-Maximization</a> algorithm for fitting the parameters of
|
||||
* Expectation-Maximization algorithm for fitting the parameters of
|
||||
* multivariate normal mixture model distributions.
|
||||
*
|
||||
* This implementation is pure original code based on <a
|
||||
|
|
|
|||
|
|
@ -30,12 +30,12 @@ import org.apache.commons.math4.fitting.leastsquares.LevenbergMarquardtOptimizer
|
|||
* real functions <code>y = f(p<sub>i</sub>;x)</code>, where {@code x} is
|
||||
* the independent variable and the <code>p<sub>i</sub></code> are the
|
||||
* <em>parameters</em>.
|
||||
* <br/>
|
||||
* <br>
|
||||
* A fitter will find the optimal values of the parameters by
|
||||
* <em>fitting</em> the curve so it remains very close to a set of
|
||||
* {@code N} observed points <code>(x<sub>k</sub>, y<sub>k</sub>)</code>,
|
||||
* {@code 0 <= k < N}.
|
||||
* <br/>
|
||||
* <br>
|
||||
* An algorithm usually performs the fit by finding the parameter
|
||||
* values that minimizes the objective function
|
||||
* <pre><code>
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* Fits points to a {@link
|
||||
* org.apache.commons.math4.analysis.function.Gaussian.Parametric Gaussian}
|
||||
* function.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The {@link #withStartPoint(double[]) initial guess values} must be passed
|
||||
* in the following order:
|
||||
* <ul>
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* Fits points to a {@link
|
||||
* org.apache.commons.math4.analysis.function.HarmonicOscillator.Parametric harmonic oscillator}
|
||||
* function.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The {@link #withStartPoint(double[]) initial guess values} must be passed
|
||||
* in the following order:
|
||||
* <ul>
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ import org.apache.commons.math4.linear.DiagonalMatrix;
|
|||
* Fits points to a {@link
|
||||
* org.apache.commons.math4.analysis.polynomials.PolynomialFunction.Parametric polynomial}
|
||||
* function.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The size of the {@link #withStartPoint(double[]) initial guess} array defines the
|
||||
* degree of the polynomial to be fitted.
|
||||
* They must be sorted in increasing order of the polynomial's degree.
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
/**
|
||||
* An implementation of {@link Evaluation} that is designed for extension. All of the
|
||||
* methods implemented here use the methods that are left unimplemented.
|
||||
* <p/>
|
||||
* <p>
|
||||
* TODO cache results?
|
||||
*
|
||||
* @since 3.3
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ public class GaussNewtonOptimizer implements LeastSquaresOptimizer {
|
|||
* using the {@link LUDecomposition}.
|
||||
*
|
||||
* <p> Theoretically this method takes mn<sup>2</sup>/2 operations to compute the
|
||||
* normal matrix and n<sup>3</sup>/3 operations (m > n) to solve the system using
|
||||
* normal matrix and n<sup>3</sup>/3 operations (m > n) to solve the system using
|
||||
* the LU decomposition. </p>
|
||||
*/
|
||||
LU {
|
||||
|
|
@ -81,7 +81,7 @@ public class GaussNewtonOptimizer implements LeastSquaresOptimizer {
|
|||
* QRDecomposition}.
|
||||
*
|
||||
* <p> Theoretically this method takes mn<sup>2</sup> - n<sup>3</sup>/3 operations
|
||||
* (m > n) and has better numerical accuracy than any method that forms the normal
|
||||
* (m > n) and has better numerical accuracy than any method that forms the normal
|
||||
* equations. </p>
|
||||
*/
|
||||
QR {
|
||||
|
|
@ -102,7 +102,7 @@ public class GaussNewtonOptimizer implements LeastSquaresOptimizer {
|
|||
* using the {@link CholeskyDecomposition}.
|
||||
*
|
||||
* <p> Theoretically this method takes mn<sup>2</sup>/2 operations to compute the
|
||||
* normal matrix and n<sup>3</sup>/6 operations (m > n) to solve the system using
|
||||
* normal matrix and n<sup>3</sup>/6 operations (m > n) to solve the system using
|
||||
* the Cholesky decomposition. </p>
|
||||
*/
|
||||
CHOLESKY {
|
||||
|
|
@ -143,7 +143,7 @@ public class GaussNewtonOptimizer implements LeastSquaresOptimizer {
|
|||
/**
|
||||
* Solve the linear least squares problem Jx=r.
|
||||
*
|
||||
* @param jacobian the Jacobian matrix, J. the number of rows >= the number or
|
||||
* @param jacobian the Jacobian matrix, J. the number of rows >= the number or
|
||||
* columns.
|
||||
* @param residuals the computed residuals, r.
|
||||
* @return the solution x, to the linear least squares problem Jx=r.
|
||||
|
|
@ -166,7 +166,7 @@ public class GaussNewtonOptimizer implements LeastSquaresOptimizer {
|
|||
|
||||
/**
|
||||
* Creates a Gauss Newton optimizer.
|
||||
* <p/>
|
||||
* <p>
|
||||
* The default for the algorithm is to solve the normal equations using QR
|
||||
* decomposition.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ public class LeastSquaresAdapter implements LeastSquaresProblem {
|
|||
}
|
||||
|
||||
/** {@inheritDoc}
|
||||
* @param point*/
|
||||
*/
|
||||
@Override
|
||||
public Evaluation evaluate(final RealVector point) {
|
||||
return problem.evaluate(point);
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ public class LeastSquaresBuilder {
|
|||
|
||||
/**
|
||||
* Configure the convergence checker.
|
||||
* <p/>
|
||||
* <p>
|
||||
* This function is an overloaded version of {@link #checker(ConvergenceChecker)}.
|
||||
*
|
||||
* @param newChecker the convergence checker.
|
||||
|
|
|
|||
|
|
@ -80,7 +80,7 @@ public interface LeastSquaresProblem extends OptimizationProblem<LeastSquaresPro
|
|||
public interface Evaluation {
|
||||
|
||||
/**
|
||||
* Get the covariance matrix of the optimized parameters. <br/> Note that this
|
||||
* Get the covariance matrix of the optimized parameters. <br> Note that this
|
||||
* operation involves the inversion of the <code>J<sup>T</sup>J</code> matrix,
|
||||
* where {@code J} is the Jacobian matrix. The {@code threshold} parameter is a
|
||||
* way for the caller to specify that the result of this computation should be
|
||||
|
|
|
|||
|
|
@ -55,9 +55,9 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* </ul>
|
||||
* The redistribution policy for MINPACK is available <a
|
||||
* href="http://www.netlib.org/minpack/disclaimer">here</a>, for convenience, it
|
||||
* is reproduced below.</p>
|
||||
* is reproduced below.
|
||||
*
|
||||
* <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
|
||||
* <table style="text-align: center; background-color: #E0E0E0" border="0" width="80%" cellpadding="10" summary="MINPACK redistribution policy">
|
||||
* <tr><td>
|
||||
* Minpack Copyright Notice (1999) University of Chicago.
|
||||
* All rights reserved
|
||||
|
|
@ -102,7 +102,7 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE,
|
||||
* EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE
|
||||
* POSSIBILITY OF SUCH LOSS OR DAMAGES.</strong></li>
|
||||
* <ol></td></tr>
|
||||
* </ol></td></tr>
|
||||
* </table>
|
||||
*
|
||||
* @since 3.3
|
||||
|
|
|
|||
|
|
@ -23,13 +23,13 @@
|
|||
* <em>cost</em> or <em>χ<sup>2</sup></em>) between model and
|
||||
* observations.
|
||||
*
|
||||
* <br/>
|
||||
* <br>
|
||||
* Algorithms in this category need access to a <em>problem</em>
|
||||
* (represented by a {@link org.apache.commons.math4.fitting.leastsquares.LeastSquaresProblem
|
||||
* LeastSquaresProblem}).
|
||||
* Such a model predicts a set of values which the algorithm tries to match
|
||||
* with a set of given set of observed values.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The problem can be created progressively using a {@link
|
||||
* org.apache.commons.math4.fitting.leastsquares.LeastSquaresBuilder builder} or it can
|
||||
* be created at once using a {@link org.apache.commons.math4.fitting.leastsquares.LeastSquaresFactory
|
||||
|
|
|
|||
|
|
@ -212,7 +212,6 @@ public class BigFraction
|
|||
* <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
|
||||
* Continued Fraction</a> equations (11) and (22)-(26)</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* @param value
|
||||
* the double value to convert to a fraction.
|
||||
|
|
@ -345,7 +344,6 @@ public class BigFraction
|
|||
* <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
|
||||
* Continued Fraction</a> equations (11) and (22)-(26)</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* @param value
|
||||
* the double value to convert to a fraction.
|
||||
|
|
|
|||
|
|
@ -109,7 +109,6 @@ public class Fraction
|
|||
* <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
|
||||
* Continued Fraction</a> equations (11) and (22)-(26)</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* @param value the double value to convert to a fraction.
|
||||
* @param epsilon maximum error allowed. The resulting fraction is within
|
||||
* {@code epsilon} of {@code value}, in absolute terms.
|
||||
|
|
@ -131,7 +130,6 @@ public class Fraction
|
|||
* <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
|
||||
* Continued Fraction</a> equations (11) and (22)-(26)</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* @param value the double value to convert to a fraction.
|
||||
* @param maxDenominator The maximum allowed value for denominator
|
||||
* @throws FractionConversionException if the continued fraction failed to
|
||||
|
|
|
|||
|
|
@ -125,7 +125,6 @@ public class GeneticAlgorithm {
|
|||
|
||||
/**
|
||||
* Evolve the given population into the next generation.
|
||||
* <p>
|
||||
* <ol>
|
||||
* <li>Get nextGeneration population to fill from <code>current</code>
|
||||
* generation, using its nextGeneration method</li>
|
||||
|
|
|
|||
|
|
@ -538,7 +538,7 @@ public class FieldVector3D<T extends RealFieldElement<T>> implements Serializabl
|
|||
* Vector3D k = u.normalize();
|
||||
* Vector3D i = k.orthogonal();
|
||||
* Vector3D j = Vector3D.crossProduct(k, i);
|
||||
* </code></pre></p>
|
||||
* </code></pre>
|
||||
* @return a new normalized vector orthogonal to the instance
|
||||
* @exception MathArithmeticException if the norm of the instance is null
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ public class Vector3D implements Serializable, Vector<Euclidean3D> {
|
|||
* Vector3D k = u.normalize();
|
||||
* Vector3D i = k.orthogonal();
|
||||
* Vector3D j = Vector3D.crossProduct(k, i);
|
||||
* </code></pre></p>
|
||||
* </code></pre>
|
||||
* @return a new normalized vector orthogonal to the instance
|
||||
* @exception MathArithmeticException if the norm of the instance is null
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ public abstract class AbstractFieldMatrix<T extends FieldElement<T>>
|
|||
}
|
||||
|
||||
/**
|
||||
* Create a new FieldMatrix<T> with the supplied row and column dimensions.
|
||||
* Create a new {@code FieldMatrix<T>} with the supplied row and column dimensions.
|
||||
*
|
||||
* @param field Field to which the elements belong.
|
||||
* @param rowDimension Number of rows in the new matrix.
|
||||
|
|
|
|||
|
|
@ -33,11 +33,11 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
import org.apache.commons.math4.util.MathUtils;
|
||||
|
||||
/**
|
||||
* Implementation of FieldMatrix<T> using a {@link FieldElement}[][] array to store entries.
|
||||
* Implementation of {@code FieldMatrix<T>} using a {@link FieldElement}[][] array to store entries.
|
||||
* <p>
|
||||
* As specified in the {@link FieldMatrix} interface, matrix element indexing
|
||||
* is 0-based -- e.g., <code>getEntry(0, 0)</code>
|
||||
* returns the element in the first row, first column of the matrix.</li></ul>
|
||||
* returns the element in the first row, first column of the matrix.
|
||||
* </p>
|
||||
*
|
||||
* @param <T> the type of the field elements
|
||||
|
|
|
|||
|
|
@ -115,9 +115,8 @@ public class BlockFieldMatrix<T extends FieldElement<T>> extends AbstractFieldMa
|
|||
* Create a new dense matrix copying entries from raw layout data.
|
||||
* <p>The input array <em>must</em> already be in raw layout.</p>
|
||||
* <p>Calling this constructor is equivalent to call:
|
||||
* <pre>matrix = new BlockFieldMatrix<T>(getField(), rawData.length, rawData[0].length,
|
||||
* toBlocksLayout(rawData), false);</pre>
|
||||
* </p>
|
||||
* {@code matrix = new BlockFieldMatrix<T>(getField(), rawData.length, rawData[0].length,
|
||||
* toBlocksLayout(rawData), false);}
|
||||
*
|
||||
* @param rawData Data for the new matrix, in raw layout.
|
||||
* @throws DimensionMismatchException if the {@code blockData} shape is
|
||||
|
|
|
|||
|
|
@ -112,7 +112,6 @@ public class BlockRealMatrix extends AbstractRealMatrix implements Serializable
|
|||
* <p>Calling this constructor is equivalent to call:
|
||||
* <pre>matrix = new BlockRealMatrix(rawData.length, rawData[0].length,
|
||||
* toBlocksLayout(rawData), false);</pre>
|
||||
* </p>
|
||||
*
|
||||
* @param rawData data for new matrix, in raw layout
|
||||
* @throws DimensionMismatchException if the shape of {@code blockData} is
|
||||
|
|
|
|||
|
|
@ -53,9 +53,9 @@ import org.apache.commons.math4.util.IterationManager;
|
|||
* <ul>
|
||||
* <li>key {@code "operator"} points to the offending linear operator, say L,</li>
|
||||
* <li>key {@code "vector"} points to the offending vector, say x, such that
|
||||
* x<sup>T</sup> · L · x < 0.</li>
|
||||
* x<sup>T</sup> · L · x < 0.</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* <h3>References</h3>
|
||||
* <dl>
|
||||
* <dt><a id="BARR1994">Barret et al. (1994)</a></dt>
|
||||
|
|
@ -64,8 +64,7 @@ import org.apache.commons.math4.util.IterationManager;
|
|||
* <a href="http://www.netlib.org/linalg/html_templates/Templates.html"><em>
|
||||
* Templates for the Solution of Linear Systems: Building Blocks for Iterative
|
||||
* Methods</em></a>, SIAM</dd>
|
||||
* <dt><a id="STRA2002">Strakos and Tichy (2002)
|
||||
* <dt>
|
||||
* <dt><a id="STRA2002">Strakos and Tichy (2002)</a></dt>
|
||||
* <dd>Z. Strakos and P. Tichy, <a
|
||||
* href="http://etna.mcs.kent.edu/vol.13.2002/pp56-80.dir/pp56-80.pdf">
|
||||
* <em>On error estimation in the conjugate gradient method and why it works
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ public class DiagonalMatrix extends AbstractRealMatrix
|
|||
|
||||
/**
|
||||
* Creates a matrix using the input array as the underlying data.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The input array is copied, not referenced.
|
||||
*
|
||||
* @param d Data for the new matrix.
|
||||
|
|
@ -65,7 +65,7 @@ public class DiagonalMatrix extends AbstractRealMatrix
|
|||
|
||||
/**
|
||||
* Creates a matrix using the input array as the underlying data.
|
||||
* <br/>
|
||||
* <br>
|
||||
* If an array is created specially in order to be embedded in a
|
||||
* this instance and not used directly, the {@code copyArray} may be
|
||||
* set to {@code false}.
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ public interface FieldMatrix<T extends FieldElement<T>> extends AnyMatrix {
|
|||
Field<T> getField();
|
||||
|
||||
/**
|
||||
* Create a new FieldMatrix<T> of the same type as the instance with
|
||||
* Create a new {@code FieldMatrix<T>} of the same type as the instance with
|
||||
* the supplied row and column dimensions.
|
||||
*
|
||||
* @param rowDimension the number of rows in the new matrix
|
||||
|
|
@ -238,7 +238,6 @@ public interface FieldMatrix<T extends FieldElement<T>> extends AnyMatrix {
|
|||
* 9 5 6 2
|
||||
* </pre>
|
||||
*
|
||||
* </p>
|
||||
*
|
||||
* @param subMatrix Array containing the submatrix replacement data.
|
||||
* @param row Row coordinate of the top-left element to be replaced.
|
||||
|
|
|
|||
|
|
@ -746,7 +746,6 @@ public class MatrixUtils {
|
|||
*
|
||||
* }
|
||||
* </code></pre>
|
||||
* </p>
|
||||
*
|
||||
* @param vector real vector to serialize
|
||||
* @param oos stream where the real vector should be written
|
||||
|
|
@ -847,7 +846,6 @@ public class MatrixUtils {
|
|||
*
|
||||
* }
|
||||
* </code></pre>
|
||||
* </p>
|
||||
*
|
||||
* @param matrix real matrix to serialize
|
||||
* @param oos stream where the real matrix should be written
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* while matrix-vector products of the type M · y remain comparatively
|
||||
* easy to compute. In this library, M (not M<sup>-1</sup>!) is called the
|
||||
* <em>preconditionner</em>.
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* Concrete implementations of this abstract class must be provided with the
|
||||
* preconditioner M, as a {@link RealLinearOperator}.
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ public class RRQRDecomposition extends QRDecomposition {
|
|||
* bottom right submatrices. When a large fall in norm is seen,
|
||||
* the rank is returned. The drop is computed as:</p>
|
||||
* <pre>
|
||||
* (thisNorm/lastNorm) * rNorm < dropThreshold
|
||||
* (thisNorm/lastNorm) * rNorm < dropThreshold
|
||||
* </pre>
|
||||
* <p>
|
||||
* where thisNorm is the Frobenius norm of the current submatrix,
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ import org.apache.commons.math4.exception.DimensionMismatchException;
|
|||
* supply a subroutine for computing y (and perhaps z) given x, which permits
|
||||
* full exploitation of the sparsity or other special structure of A.
|
||||
* </blockquote>
|
||||
* <br/>
|
||||
* <br>
|
||||
*
|
||||
* <dl>
|
||||
* <dt><a name="BARR1994">Barret et al. (1994)</a></dt>
|
||||
|
|
|
|||
|
|
@ -244,7 +244,7 @@ public interface RealMatrix extends AnyMatrix {
|
|||
* 1 2 3 4
|
||||
* 5 3 4 8
|
||||
* 9 5 6 2
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* @param subMatrix array containing the submatrix replacement data
|
||||
* @param row row coordinate of the top, left element to be replaced
|
||||
|
|
|
|||
|
|
@ -803,12 +803,12 @@ public abstract class RealVector {
|
|||
|
||||
/**
|
||||
* Acts as if it is implemented as:
|
||||
* <pre>
|
||||
* {@code
|
||||
* Entry e = null;
|
||||
* for(Iterator<Entry> it = iterator(); it.hasNext(); e = it.next()) {
|
||||
* e.setValue(function.value(e.getValue()));
|
||||
* }
|
||||
* </pre>
|
||||
* }
|
||||
* Entries of this vector are modified in-place by this method.
|
||||
*
|
||||
* @param function Function to apply to each entry.
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* of the traditional triangular shape) and there is a threshold to ignore
|
||||
* small diagonal elements. This is used for example to generate {@link
|
||||
* org.apache.commons.math4.random.CorrelatedRandomVectorGenerator correlated
|
||||
* random n-dimensions vectors} in a p-dimension subspace (p < n).
|
||||
* random n-dimensions vectors} in a p-dimension subspace (p < n).
|
||||
* In other words, it allows generating random vectors from a covariance
|
||||
* matrix that is only positive semidefinite, and not positive definite.</p>
|
||||
* <p>Rectangular Cholesky decomposition is <em>not</em> suited for solving
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ public class SparseFieldMatrix<T extends FieldElement<T>> extends AbstractFieldM
|
|||
}
|
||||
|
||||
/**
|
||||
* Create a new SparseFieldMatrix<T> with the supplied row and column
|
||||
* Create a new {@code SparseFieldMatrix<T>} with the supplied row and column
|
||||
* dimensions.
|
||||
*
|
||||
* @param field Field to which the elements belong.
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* initial phase. If x<sub>0</sub> is known to be a good approximation to x, one
|
||||
* should compute r<sub>0</sub> = b - A · x, solve A · dx = r0,
|
||||
* and set x = x<sub>0</sub> + dx.
|
||||
* </p>
|
||||
*
|
||||
* <h3><a id="context">Exception context</a></h3>
|
||||
* <p>
|
||||
* Besides standard {@link DimensionMismatchException}, this class might throw
|
||||
|
|
@ -127,7 +127,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* that x<sup>T</sup> · L · y ≠ y<sup>T</sup> · L
|
||||
* · x (within a certain accuracy).</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* {@link NonPositiveDefiniteOperatorException} might also be thrown in case the
|
||||
* preconditioner is not positive definite. The relevant keys to the
|
||||
|
|
@ -136,9 +136,9 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* <li>key {@code "operator"}, which points to the offending linear operator,
|
||||
* say L,</li>
|
||||
* <li>key {@code "vector"}, which points to the offending vector, say x, such
|
||||
* that x<sup>T</sup> · L · x < 0.</li>
|
||||
* that x<sup>T</sup> · L · x < 0.</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* <h3>References</h3>
|
||||
* <dl>
|
||||
* <dt><a id="PAIG1975">Paige and Saunders (1975)</a></dt>
|
||||
|
|
|
|||
|
|
@ -43,9 +43,9 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* to the cluster j.
|
||||
* <p>
|
||||
* The algorithm then tries to minimize the objective function:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* J = ∑<sub>i=1..C</sub>∑<sub>k=1..N</sub> u<sub>ik</sub><sup>m</sup>d<sub>ik</sub><sup>2</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* with d<sub>ik</sub> being the distance between data point i and the cluster center k.
|
||||
* <p>
|
||||
* The algorithm requires two parameters:
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ public class Neuron implements Serializable {
|
|||
* Creates a neuron.
|
||||
* The size of the feature set is fixed to the length of the given
|
||||
* argument.
|
||||
* <br/>
|
||||
* <br>
|
||||
* Constructor is package-private: Neurons must be
|
||||
* {@link Network#createNeuron(double[]) created} by the network
|
||||
* instance to which they will belong.
|
||||
|
|
@ -113,7 +113,7 @@ public class Neuron implements Serializable {
|
|||
/**
|
||||
* Tries to atomically update the neuron's features.
|
||||
* Update will be performed only if the expected values match the
|
||||
* current values.<br/>
|
||||
* current values.<br>
|
||||
* In effect, when concurrent threads call this method, the state
|
||||
* could be modified by one, so that it does not correspond to the
|
||||
* the state assumed by another.
|
||||
|
|
|
|||
|
|
@ -24,13 +24,13 @@ package org.apache.commons.math4.ml.neuralnet;
|
|||
*/
|
||||
public enum SquareNeighbourhood {
|
||||
/**
|
||||
* <a href="http://en.wikipedia.org/wiki/Von_Neumann_neighborhood"
|
||||
* <a href="http://en.wikipedia.org/wiki/Von_Neumann_neighborhood">
|
||||
* Von Neumann neighbourhood</a>: in two dimensions, each (internal)
|
||||
* neuron has four neighbours.
|
||||
*/
|
||||
VON_NEUMANN,
|
||||
/**
|
||||
* <a href="http://en.wikipedia.org/wiki/Moore_neighborhood"
|
||||
* <a href="http://en.wikipedia.org/wiki/Moore_neighborhood">
|
||||
* Moore neighbourhood</a>: in two dimensions, each (internal)
|
||||
* neuron has eight neighbours.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -83,11 +83,11 @@ public class NeuronString implements Serializable {
|
|||
* Creates a one-dimensional network:
|
||||
* Each neuron not located on the border of the mesh has two
|
||||
* neurons linked to it.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The links are bi-directional.
|
||||
* Neurons created successively are neighbours (i.e. there are
|
||||
* links between them).
|
||||
* <br/>
|
||||
* <br>
|
||||
* The topology of the network can also be a circle (if the
|
||||
* dimension is wrapped).
|
||||
*
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ import org.apache.commons.math4.ml.neuralnet.UpdateAction;
|
|||
/**
|
||||
* Update formula for <a href="http://en.wikipedia.org/wiki/Kohonen">
|
||||
* Kohonen's Self-Organizing Map</a>.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The {@link #update(Network,double[]) update} method modifies the
|
||||
* features {@code w} of the "winning" neuron and its neighbours
|
||||
* according to the following rule:
|
||||
|
|
@ -46,12 +46,12 @@ import org.apache.commons.math4.ml.neuralnet.UpdateAction;
|
|||
* <li>{@code d} is the number of links to traverse in order to reach
|
||||
* the neuron from the winning neuron.</li>
|
||||
* </ul>
|
||||
* <br/>
|
||||
* <br>
|
||||
* This class is thread-safe as long as the arguments passed to the
|
||||
* {@link #KohonenUpdateAction(DistanceMeasure,LearningFactorFunction,
|
||||
* NeighbourhoodSizeFunction) constructor} are instances of thread-safe
|
||||
* classes.
|
||||
* <br/>
|
||||
* <br>
|
||||
* Each call to the {@link #update(Network,double[]) update} method
|
||||
* will increment the internal counter used to compute the current
|
||||
* values for
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
/**
|
||||
* Exponential decay function: <code>a e<sup>-x / b</sup></code>,
|
||||
* where {@code x} is the (integer) independent variable.
|
||||
* <br/>
|
||||
* <br>
|
||||
* Class is immutable.
|
||||
*
|
||||
* @since 3.3
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ import org.apache.commons.math4.exception.NumberIsTooLargeException;
|
|||
|
||||
/**
|
||||
* Decay function whose shape is similar to a sigmoid.
|
||||
* <br/>
|
||||
* <br>
|
||||
* Class is immutable.
|
||||
*
|
||||
* @since 3.3
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ import org.apache.commons.math4.ml.neuralnet.SquareNeighbourhood;
|
|||
/**
|
||||
* Neural network with the topology of a two-dimensional surface.
|
||||
* Each neuron defines one surface element.
|
||||
* <br/>
|
||||
* <br>
|
||||
* This network is primarily intended to represent a
|
||||
* <a href="http://en.wikipedia.org/wiki/Kohonen">
|
||||
* Self Organizing Feature Map</a>.
|
||||
|
|
@ -141,9 +141,9 @@ public class NeuronSquareMesh2D
|
|||
* Creates a two-dimensional network composed of square cells:
|
||||
* Each neuron not located on the border of the mesh has four
|
||||
* neurons linked to it.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The links are bi-directional.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The topology of the network can also be a cylinder (if one
|
||||
* of the dimensions is wrapped) or a torus (if both dimensions
|
||||
* are wrapped).
|
||||
|
|
|
|||
|
|
@ -26,11 +26,11 @@ import org.apache.commons.math4.exception.NumberIsTooSmallException;
|
|||
/**
|
||||
* Visualization of high-dimensional data projection on a 2D-map.
|
||||
* The method is described in
|
||||
* <quote>
|
||||
* <blockquote>
|
||||
* <em>Using Smoothed Data Histograms for Cluster Visualization in Self-Organizing Maps</em>
|
||||
* <br>
|
||||
* by Elias Pampalk, Andreas Rauber and Dieter Merkl.
|
||||
* </quote>
|
||||
* </blockquote>
|
||||
* @since 3.6
|
||||
*/
|
||||
public class SmoothedDataHistogram implements MapDataVisualization {
|
||||
|
|
|
|||
|
|
@ -43,7 +43,6 @@ import org.apache.commons.math4.exception.util.LocalizedFormats;
|
|||
* <li>a {@link ParameterJacobianProvider}</li>
|
||||
* <li>a {@link ParameterizedODE}</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* @see ExpandableStatefulODE
|
||||
* @see FirstOrderDifferentialEquations
|
||||
|
|
|
|||
|
|
@ -38,20 +38,20 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* This class is the base class for multistep integrators for Ordinary
|
||||
* Differential Equations.
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
* <p>Rather than storing several previous steps separately, this implementation uses
|
||||
* the Nordsieck vector with higher degrees scaled derivatives all taken at the same
|
||||
* step (y<sub>n</sub>, s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* (we omit the k index in the notation for clarity)</p>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity)
|
||||
* <p>
|
||||
* Multistep integrators with Nordsieck representation are highly sensitive to
|
||||
* large step changes because when the step is multiplied by factor a, the
|
||||
|
|
|
|||
|
|
@ -34,20 +34,20 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* This class is the base class for multistep integrators for Ordinary
|
||||
* Differential Equations.
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
* <p>Rather than storing several previous steps separately, this implementation uses
|
||||
* the Nordsieck vector with higher degrees scaled derivatives all taken at the same
|
||||
* step (y<sub>n</sub>, s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* (we omit the k index in the notation for clarity)</p>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity)
|
||||
* <p>
|
||||
* Multistep integrators with Nordsieck representation are highly sensitive to
|
||||
* large step changes because when the step is multiplied by factor a, the
|
||||
|
|
|
|||
|
|
@ -110,7 +110,7 @@ public interface EventHandler {
|
|||
* <p>Also note that the integrator expect that once an event has occurred,
|
||||
* the sign of the switching function at the start of the next step (i.e.
|
||||
* just after the event) is the opposite of the sign just before the event.
|
||||
* This consistency between the steps <string>must</strong> be preserved,
|
||||
* This consistency between the steps <strong>must</strong> be preserved,
|
||||
* otherwise {@link org.apache.commons.math4.exception.NoBracketingException
|
||||
* exceptions} related to root not being bracketed will occur.</p>
|
||||
* <p>This need for consistency is sometimes tricky to achieve. A typical
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ public interface FieldEventHandler<T extends RealFieldElement<T>> {
|
|||
* <p>Also note that the integrator expect that once an event has occurred,
|
||||
* the sign of the switching function at the start of the next step (i.e.
|
||||
* just after the event) is the opposite of the sign just before the event.
|
||||
* This consistency between the steps <string>must</strong> be preserved,
|
||||
* This consistency between the steps <strong>must</strong> be preserved,
|
||||
* otherwise {@link org.apache.commons.math4.exception.NoBracketingException
|
||||
* exceptions} related to root not being bracketed will occur.</p>
|
||||
* <p>This need for consistency is sometimes tricky to achieve. A typical
|
||||
|
|
|
|||
|
|
@ -56,19 +56,19 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* <h3>Implementation details</h3>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>The definitions above use the classical representation with several previous first
|
||||
* derivatives. Lets define
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity). With these definitions,
|
||||
* Adams-Bashforth methods can be written:
|
||||
* <ul>
|
||||
|
|
@ -77,30 +77,29 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 23/12 s<sub>1</sub>(n) + [ -16/12 5/12 ] q<sub>n</sub></li>
|
||||
* <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 55/24 s<sub>1</sub>(n) + [ -59/24 37/24 -9/24 ] q<sub>n</sub></li>
|
||||
* <li>...</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n) and q<sub>n</sub>), our implementation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n)
|
||||
* and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -110,7 +109,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Using the Nordsieck vector has several advantages:
|
||||
* <ul>
|
||||
|
|
@ -119,7 +118,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* <li>it simplifies step changes that occur when discrete events that truncate
|
||||
* the step are triggered,</li>
|
||||
* <li>it allows to extend the methods in order to support adaptive stepsize.</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The Nordsieck vector at step n+1 is computed from the Nordsieck vector at step n as follows:
|
||||
* <ul>
|
||||
|
|
@ -136,7 +135,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* [ ... | 0 ]
|
||||
* [ 0 0 ... 1 0 | 0 ]
|
||||
* [ 0 0 ... 0 1 | 0 ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state,
|
||||
* they only depend on k and therefore are precomputed once for all.</p>
|
||||
|
|
|
|||
|
|
@ -54,19 +54,19 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <h3>Implementation details</h3>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>The definitions above use the classical representation with several previous first
|
||||
* derivatives. Lets define
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity). With these definitions,
|
||||
* Adams-Bashforth methods can be written:
|
||||
* <ul>
|
||||
|
|
@ -75,30 +75,29 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 23/12 s<sub>1</sub>(n) + [ -16/12 5/12 ] q<sub>n</sub></li>
|
||||
* <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 55/24 s<sub>1</sub>(n) + [ -59/24 37/24 -9/24 ] q<sub>n</sub></li>
|
||||
* <li>...</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n) and q<sub>n</sub>), our implementation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n)
|
||||
* and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -108,7 +107,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Using the Nordsieck vector has several advantages:
|
||||
* <ul>
|
||||
|
|
@ -117,7 +116,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <li>it simplifies step changes that occur when discrete events that truncate
|
||||
* the step are triggered,</li>
|
||||
* <li>it allows to extend the methods in order to support adaptive stepsize.</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The Nordsieck vector at step n+1 is computed from the Nordsieck vector at step n as follows:
|
||||
* <ul>
|
||||
|
|
@ -134,7 +133,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* [ ... | 0 ]
|
||||
* [ 0 0 ... 1 0 | 0 ]
|
||||
* [ 0 0 ... 0 1 | 0 ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state,
|
||||
* they only depend on k and therefore are precomputed once for all.</p>
|
||||
|
|
|
|||
|
|
@ -112,10 +112,10 @@ public abstract class AdamsFieldIntegrator<T extends RealFieldElement<T>> extend
|
|||
|
||||
/** Update the high order scaled derivatives for Adams integrators (phase 1).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p>
|
||||
* </code></div>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.
|
||||
* @param highOrder high order scaled derivatives
|
||||
* (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k))
|
||||
* @return updated high order derivatives
|
||||
|
|
@ -127,10 +127,10 @@ public abstract class AdamsFieldIntegrator<T extends RealFieldElement<T>> extend
|
|||
|
||||
/** Update the high order scaled derivatives Adams integrators (phase 2).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p>
|
||||
* </code></div>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.
|
||||
* <p>Phase 1 of the update must already have been performed.</p>
|
||||
* @param start first order scaled derivatives at step start
|
||||
* @param end first order scaled derivatives at step end
|
||||
|
|
|
|||
|
|
@ -101,10 +101,10 @@ public abstract class AdamsIntegrator extends MultistepIntegrator {
|
|||
|
||||
/** Update the high order scaled derivatives for Adams integrators (phase 1).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p>
|
||||
* </code></div>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.
|
||||
* @param highOrder high order scaled derivatives
|
||||
* (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k))
|
||||
* @return updated high order derivatives
|
||||
|
|
@ -116,10 +116,10 @@ public abstract class AdamsIntegrator extends MultistepIntegrator {
|
|||
|
||||
/** Update the high order scaled derivatives Adams integrators (phase 2).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p>
|
||||
* </code></div>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.
|
||||
* <p>Phase 1 of the update must already have been performed.</p>
|
||||
* @param start first order scaled derivatives at step start
|
||||
* @param end first order scaled derivatives at step end
|
||||
|
|
|
|||
|
|
@ -62,19 +62,19 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* <h3>Implementation details</h3>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>The definitions above use the classical representation with several previous first
|
||||
* derivatives. Lets define
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity). With these definitions,
|
||||
* Adams-Moulton methods can be written:
|
||||
* <ul>
|
||||
|
|
@ -83,30 +83,29 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 5/12 s<sub>1</sub>(n+1) + [ 8/12 -1/12 ] q<sub>n+1</sub></li>
|
||||
* <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 9/24 s<sub>1</sub>(n+1) + [ 19/24 -5/24 1/24 ] q<sub>n+1</sub></li>
|
||||
* <li>...</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n+1) and q<sub>n+1</sub>), our implementation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n)
|
||||
* and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -116,7 +115,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Using the Nordsieck vector has several advantages:
|
||||
* <ul>
|
||||
|
|
@ -125,7 +124,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* <li>it simplifies step changes that occur when discrete events that truncate
|
||||
* the step are triggered,</li>
|
||||
* <li>it allows to extend the methods in order to support adaptive stepsize.</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step
|
||||
* n as follows:
|
||||
|
|
@ -152,7 +151,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* </ul>
|
||||
* where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the
|
||||
* predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub>
|
||||
* represent the corrected states.</p>
|
||||
* represent the corrected states.
|
||||
*
|
||||
* <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state,
|
||||
* they only depend on k and therefore are precomputed once for all.</p>
|
||||
|
|
|
|||
|
|
@ -59,19 +59,19 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <h3>Implementation details</h3>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>The definitions above use the classical representation with several previous first
|
||||
* derivatives. Lets define
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity). With these definitions,
|
||||
* Adams-Moulton methods can be written:
|
||||
* <ul>
|
||||
|
|
@ -80,30 +80,29 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + 5/12 s<sub>1</sub>(n+1) + [ 8/12 -1/12 ] q<sub>n+1</sub></li>
|
||||
* <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + 9/24 s<sub>1</sub>(n+1) + [ 19/24 -5/24 1/24 ] q<sub>n+1</sub></li>
|
||||
* <li>...</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>Instead of using the classical representation with first derivatives only (y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n+1) and q<sub>n+1</sub>), our implementation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step (y<sub>n</sub>, s<sub>1</sub>(n)
|
||||
* and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -113,7 +112,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Using the Nordsieck vector has several advantages:
|
||||
* <ul>
|
||||
|
|
@ -122,7 +121,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* <li>it simplifies step changes that occur when discrete events that truncate
|
||||
* the step are triggered,</li>
|
||||
* <li>it allows to extend the methods in order to support adaptive stepsize.</li>
|
||||
* </ul></p>
|
||||
* </ul>
|
||||
*
|
||||
* <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step
|
||||
* n as follows:
|
||||
|
|
@ -149,7 +148,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* </ul>
|
||||
* where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the
|
||||
* predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub>
|
||||
* represent the corrected states.</p>
|
||||
* represent the corrected states.
|
||||
*
|
||||
* <p>The P<sup>-1</sup>u vector and the P<sup>-1</sup> A P matrix do not depend on the state,
|
||||
* they only depend on k and therefore are precomputed once for all.</p>
|
||||
|
|
|
|||
|
|
@ -37,43 +37,42 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* representation with higher order scaled derivatives.</p>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>With the previous definition, the classical representation of multistep methods
|
||||
* uses first derivatives only, i.e. it handles y<sub>n</sub>, s<sub>1</sub>(n) and
|
||||
* q<sub>n</sub> where q<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* (we omit the k index in the notation for clarity).</p>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity).
|
||||
*
|
||||
* <p>Another possible representation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step, i.e it handles y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector at step end. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -83,7 +82,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Changing -i into +i in the formula above can be used to compute a similar transform between
|
||||
* classical representation and Nordsieck vector at step start. The resulting matrix is simply
|
||||
|
|
@ -105,7 +104,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* [ ... | 0 ]
|
||||
* [ 0 0 ... 1 0 | 0 ]
|
||||
* [ 0 0 ... 0 1 | 0 ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>For {@link AdamsMoultonIntegrator Adams-Moulton} method, the predicted Nordsieck vector
|
||||
* at step n+1 is computed from the Nordsieck vector at step n as follows:
|
||||
|
|
@ -122,7 +121,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* </ul>
|
||||
* where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the
|
||||
* predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub>
|
||||
* represent the corrected states.</p>
|
||||
* represent the corrected states.
|
||||
*
|
||||
* <p>We observe that both methods use similar update formulas. In both cases a P<sup>-1</sup>u
|
||||
* vector and a P<sup>-1</sup> A P matrix are used that do not depend on the state,
|
||||
|
|
@ -218,7 +217,7 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> {
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
* @param rows number of rows of the matrix
|
||||
* @return P matrix
|
||||
*/
|
||||
|
|
@ -318,10 +317,10 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> {
|
|||
|
||||
/** Update the high order scaled derivatives for Adams integrators (phase 1).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p>
|
||||
* </code></div>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.
|
||||
* @param highOrder high order scaled derivatives
|
||||
* (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k))
|
||||
* @return updated high order derivatives
|
||||
|
|
@ -333,10 +332,10 @@ public class AdamsNordsieckFieldTransformer<T extends RealFieldElement<T>> {
|
|||
|
||||
/** Update the high order scaled derivatives Adams integrators (phase 2).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p>
|
||||
* </code></div>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.
|
||||
* <p>Phase 1 of the update must already have been performed.</p>
|
||||
* @param start first order scaled derivatives at step start
|
||||
* @param end first order scaled derivatives at step end
|
||||
|
|
|
|||
|
|
@ -39,43 +39,42 @@ import org.apache.commons.math4.linear.RealMatrix;
|
|||
* representation with higher order scaled derivatives.</p>
|
||||
*
|
||||
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n) = h y'<sub>n</sub> for first derivative
|
||||
* s<sub>2</sub>(n) = h<sup>2</sup>/2 y''<sub>n</sub> for second derivative
|
||||
* s<sub>3</sub>(n) = h<sup>3</sup>/6 y'''<sub>n</sub> for third derivative
|
||||
* ...
|
||||
* s<sub>k</sub>(n) = h<sup>k</sup>/k! y<sup>(k)</sup><sub>n</sub> for k<sup>th</sup> derivative
|
||||
* </pre></p>
|
||||
* </code></div>
|
||||
*
|
||||
* <p>With the previous definition, the classical representation of multistep methods
|
||||
* uses first derivatives only, i.e. it handles y<sub>n</sub>, s<sub>1</sub>(n) and
|
||||
* q<sub>n</sub> where q<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = [ s<sub>1</sub>(n-1) s<sub>1</sub>(n-2) ... s<sub>1</sub>(n-(k-1)) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* (we omit the k index in the notation for clarity).</p>
|
||||
* </code></div>
|
||||
* (we omit the k index in the notation for clarity).
|
||||
*
|
||||
* <p>Another possible representation uses the Nordsieck vector with
|
||||
* higher degrees scaled derivatives all taken at the same step, i.e it handles y<sub>n</sub>,
|
||||
* s<sub>1</sub>(n) and r<sub>n</sub>) where r<sub>n</sub> is defined as:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* (here again we omit the k index in the notation for clarity)
|
||||
* </p>
|
||||
*
|
||||
* <p>Taylor series formulas show that for any index offset i, s<sub>1</sub>(n-i) can be
|
||||
* computed from s<sub>1</sub>(n), s<sub>2</sub>(n) ... s<sub>k</sub>(n), the formula being exact
|
||||
* for degree k polynomials.
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* s<sub>1</sub>(n-i) = s<sub>1</sub>(n) + ∑<sub>j>0</sub> (j+1) (-i)<sup>j</sup> s<sub>j+1</sub>(n)
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* The previous formula can be used with several values for i to compute the transform between
|
||||
* classical representation and Nordsieck vector at step end. The transform between r<sub>n</sub>
|
||||
* and q<sub>n</sub> resulting from the Taylor series formulas above is:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
|
||||
* </pre>
|
||||
* </code></div>
|
||||
* where u is the [ 1 1 ... 1 ]<sup>T</sup> vector and P is the (k-1)×(k-1) matrix built
|
||||
* with the (j+1) (-i)<sup>j</sup> terms with i being the row number starting from 1 and j being
|
||||
* the column number starting from 1:
|
||||
|
|
@ -85,7 +84,7 @@ import org.apache.commons.math4.linear.RealMatrix;
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>Changing -i into +i in the formula above can be used to compute a similar transform between
|
||||
* classical representation and Nordsieck vector at step start. The resulting matrix is simply
|
||||
|
|
@ -107,7 +106,7 @@ import org.apache.commons.math4.linear.RealMatrix;
|
|||
* [ ... | 0 ]
|
||||
* [ 0 0 ... 1 0 | 0 ]
|
||||
* [ 0 0 ... 0 1 | 0 ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* <p>For {@link AdamsMoultonIntegrator Adams-Moulton} method, the predicted Nordsieck vector
|
||||
* at step n+1 is computed from the Nordsieck vector at step n as follows:
|
||||
|
|
@ -124,7 +123,7 @@ import org.apache.commons.math4.linear.RealMatrix;
|
|||
* </ul>
|
||||
* where the upper case Y<sub>n+1</sub>, S<sub>1</sub>(n+1) and R<sub>n+1</sub> represent the
|
||||
* predicted states whereas the lower case y<sub>n+1</sub>, s<sub>n+1</sub> and r<sub>n+1</sub>
|
||||
* represent the corrected states.</p>
|
||||
* represent the corrected states.
|
||||
*
|
||||
* <p>We observe that both methods use similar update formulas. In both cases a P<sup>-1</sup>u
|
||||
* vector and a P<sup>-1</sup> A P matrix are used that do not depend on the state,
|
||||
|
|
@ -220,7 +219,7 @@ public class AdamsNordsieckTransformer {
|
|||
* P = [ -6 27 -108 405 ... ]
|
||||
* [ -8 48 -256 1280 ... ]
|
||||
* [ ... ]
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
* @param rows number of rows of the matrix
|
||||
* @return P matrix
|
||||
*/
|
||||
|
|
@ -319,10 +318,10 @@ public class AdamsNordsieckTransformer {
|
|||
|
||||
/** Update the high order scaled derivatives for Adams integrators (phase 1).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.</p>
|
||||
* </code></div>
|
||||
* this method computes the P<sup>-1</sup> A P r<sub>n</sub> part.
|
||||
* @param highOrder high order scaled derivatives
|
||||
* (h<sup>2</sup>/2 y'', ... h<sup>k</sup>/k! y(k))
|
||||
* @return updated high order derivatives
|
||||
|
|
@ -334,10 +333,10 @@ public class AdamsNordsieckTransformer {
|
|||
|
||||
/** Update the high order scaled derivatives Adams integrators (phase 2).
|
||||
* <p>The complete update of high order derivatives has a form similar to:
|
||||
* <pre>
|
||||
* <div style="white-space: pre"><code>
|
||||
* r<sub>n+1</sub> = (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u + P<sup>-1</sup> A P r<sub>n</sub>
|
||||
* </pre>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.</p>
|
||||
* </code></div>
|
||||
* this method computes the (s<sub>1</sub>(n) - s<sub>1</sub>(n+1)) P<sup>-1</sup> u part.
|
||||
* <p>Phase 1 of the update must already have been performed.</p>
|
||||
* @param start first order scaled derivatives at step start
|
||||
* @param end first order scaled derivatives at step end
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* state vector and relTol_i is the relative tolerance for the same
|
||||
* component. The user can also use only two scalar values absTol and
|
||||
* relTol which will be used for all components.
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* Note that <em>only</em> the {@link FieldODEState#getState() main part}
|
||||
* of the state vector is used for stepsize control. The {@link
|
||||
|
|
@ -55,12 +55,12 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
*
|
||||
* <p>If the estimated error for ym+1 is such that
|
||||
* <pre>
|
||||
* sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1
|
||||
* sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1
|
||||
* </pre>
|
||||
*
|
||||
* (where n is the main set dimension) then the step is accepted,
|
||||
* otherwise the step is rejected and a new attempt is made with a new
|
||||
* stepsize.</p>
|
||||
* stepsize.
|
||||
*
|
||||
* @param <T> the type of the field elements
|
||||
* @since 3.6
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* state vector and relTol_i is the relative tolerance for the same
|
||||
* component. The user can also use only two scalar values absTol and
|
||||
* relTol which will be used for all components.
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* If the Ordinary Differential Equations is an {@link ExpandableStatefulODE
|
||||
* extended ODE} rather than a {@link
|
||||
|
|
@ -51,12 +51,12 @@ import org.apache.commons.math4.util.FastMath;
|
|||
*
|
||||
* <p>If the estimated error for ym+1 is such that
|
||||
* <pre>
|
||||
* sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1
|
||||
* sqrt((sum (errEst_i / threshold_i)^2 ) / n) < 1
|
||||
* </pre>
|
||||
*
|
||||
* (where n is the main set dimension) then the step is accepted,
|
||||
* otherwise the step is rejected and a new attempt is made with a new
|
||||
* stepsize.</p>
|
||||
* stepsize.
|
||||
*
|
||||
* @since 1.2
|
||||
*
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |--------------------
|
||||
* | 1/6 1/3 1/3 1/6
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see GillFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -45,7 +45,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@ package org.apache.commons.math4.ode.nonstiff;
|
|||
* |--------------------
|
||||
* | 1/6 1/3 1/3 1/6
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see GillIntegrator
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* J. R. Dormand and P. J. Prince
|
||||
* Journal of Computational and Applied Mathematics
|
||||
* volume 6, no 1, 1980, pp. 19-26
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* @param <T> the type of the field elements
|
||||
* @since 3.6
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* J. R. Dormand and P. J. Prince
|
||||
* Journal of Computational and Applied Mathematics
|
||||
* volume 6, no 1, 1980, pp. 19-26
|
||||
* </pre></p>
|
||||
* </pre>
|
||||
*
|
||||
* @since 1.2
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -47,7 +47,6 @@ import org.apache.commons.math4.util.MathUtils;
|
|||
* | b1 b2 ... bs-1 bs
|
||||
* | b'1 b'2 ... b's-1 b's
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* <p>In fact, we rather use the array defined by ej = bj - b'j to
|
||||
* compute directly the error rather than computing two estimates and
|
||||
|
|
|
|||
|
|
@ -41,7 +41,6 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* | b1 b2 ... bs-1 bs
|
||||
* | b'1 b'2 ... b's-1 b's
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* <p>In fact, we rather use the array defined by ej = bj - b'j to
|
||||
* compute directly the error rather than computing two estimates and
|
||||
|
|
|
|||
|
|
@ -36,7 +36,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative;
|
|||
* y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) - (1-θ) h y'
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y' is the evaluation of
|
||||
* the derivatives already computed during the step.</p>
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator;
|
|||
* y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) - (1-θ) h y'
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y' is the evaluation of
|
||||
* the derivatives already computed during the step.</p>
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |-------------------------------
|
||||
* | 1/6 (2-q)/6 (2+q)/6 1/6
|
||||
* </pre>
|
||||
* where q = sqrt(2)</p>
|
||||
* where q = sqrt(2)
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see ClassicalRungeKuttaFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -45,7 +45,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub>
|
||||
* are the four evaluations of the derivatives already computed during
|
||||
* the step.</p>
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* |-------------------------------
|
||||
* | 1/6 (2-q)/6 (2+q)/6 1/6
|
||||
* </pre>
|
||||
* where q = sqrt(2)</p>
|
||||
* where q = sqrt(2)
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see ClassicalRungeKuttaIntegrator
|
||||
|
|
|
|||
|
|
@ -43,7 +43,6 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub>
|
||||
* are the four evaluations of the derivatives already computed during
|
||||
* the step.</p>
|
||||
|
|
|
|||
|
|
@ -61,9 +61,8 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* for this code is available <a
|
||||
* href="http://www.unige.ch/~hairer/prog/licence.txt">here</a>, for
|
||||
* convenience, it is reproduced below.</p>
|
||||
* </p>
|
||||
*
|
||||
* <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
|
||||
* <table border="0" width="80%" cellpadding="10" style="text-align: center; background-color: #E0E0E0" summary="odex redistribution policy">
|
||||
* <tr><td>Copyright (c) 2004, Ernst Hairer</td></tr>
|
||||
*
|
||||
* <tr><td>Redistribution and use in source and binary forms, with or
|
||||
|
|
@ -240,13 +239,13 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
|
|||
* </pre>
|
||||
* where err is the scaled error and k the iteration number of the
|
||||
* extrapolation scheme (counting from 0). The default values are
|
||||
* 0.65 for stepControl1 and 0.94 for stepControl2.</p>
|
||||
* 0.65 for stepControl1 and 0.94 for stepControl2.
|
||||
* <p>The step size is subject to the restriction:
|
||||
* <pre>
|
||||
* stepControl3^(1/(2k+1))/stepControl4 <= hNew/h <= 1/stepControl3^(1/(2k+1))
|
||||
* stepControl3^(1/(2k+1))/stepControl4 <= hNew/h <= 1/stepControl3^(1/(2k+1))
|
||||
* </pre>
|
||||
* The default values are 0.02 for stepControl3 and 4.0 for
|
||||
* stepControl4.</p>
|
||||
* stepControl4.
|
||||
* @param control1 first stepsize control factor (the factor is
|
||||
* reset to default if lower than 0.0001 or greater than 0.9999)
|
||||
* @param control2 second stepsize control factor (the factor
|
||||
|
|
@ -292,8 +291,8 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
|
|||
* maximal order that will be used is always even, it is twice the
|
||||
* maximal number of columns in the extrapolation table.</p>
|
||||
* <pre>
|
||||
* order is decreased if w(k-1) <= w(k) * orderControl1
|
||||
* order is increased if w(k) <= w(k-1) * orderControl2
|
||||
* order is decreased if w(k-1) <= w(k) * orderControl1
|
||||
* order is increased if w(k) <= w(k-1) * orderControl2
|
||||
* </pre>
|
||||
* <p>where w is the table of work per unit step for each order
|
||||
* (number of function calls divided by the step length), and k is
|
||||
|
|
@ -302,7 +301,7 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
|
|||
* maximal number of columns is 9). The default values are 0.8 for
|
||||
* orderControl1 and 0.9 for orderControl2.</p>
|
||||
* @param maximalOrder maximal order in the extrapolation table (the
|
||||
* maximal order is reset to default if order <= 6 or odd)
|
||||
* maximal order is reset to default if order <= 6 or odd)
|
||||
* @param control1 first order control factor (the factor is
|
||||
* reset to default if lower than 0.0001 or greater than 0.9999)
|
||||
* @param control2 second order control factor (the factor
|
||||
|
|
@ -403,7 +402,7 @@ public class GraggBulirschStoerIntegrator extends AdaptiveStepsizeIntegrator {
|
|||
* @param useInterpolationErrorForControl if true, interpolation error is used
|
||||
* for stepsize control
|
||||
* @param mudifControlParameter interpolation order control parameter (the parameter
|
||||
* is reset to default if <= 0 or >= 7)
|
||||
* is reset to default if <= 0 or >= 7)
|
||||
*/
|
||||
public void setInterpolationControl(final boolean useInterpolationErrorForControl,
|
||||
final int mudifControlParameter) {
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |--------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
* | 1/20 0 16/45 0 49/180 49/180 1/20
|
||||
* </pre>
|
||||
* where q = √21</p>
|
||||
* where q = √21
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see ClassicalRungeKuttaFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* |--------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
* | 1/20 0 16/45 0 49/180 49/180 1/20
|
||||
* </pre>
|
||||
* where q = √21</p>
|
||||
* where q = √21
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see ClassicalRungeKuttaIntegrator
|
||||
|
|
|
|||
|
|
@ -35,7 +35,6 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |----------
|
||||
* | 0 1
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see ClassicalRungeKuttaFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -37,7 +37,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative;
|
|||
* y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) + (1-θ) h [θ y'<sub>1</sub> - (1+θ) y'<sub>2</sub>]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> and y'<sub>2</sub> are the two
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -30,7 +30,6 @@ package org.apache.commons.math4.ode.nonstiff;
|
|||
* |----------
|
||||
* | 0 1
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see ClassicalRungeKuttaIntegrator
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator;
|
|||
* y(t<sub>n</sub> + θ h) = y (t<sub>n</sub> + h) + (1-θ) h [θ y'<sub>1</sub> - (1+θ) y'<sub>2</sub>]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> and y'<sub>2</sub> are the two
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -47,7 +47,6 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |--------------------------
|
||||
* | b1 b2 ... bs-1 bs
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see ClassicalRungeKuttaFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@ import org.apache.commons.math4.util.FastMath;
|
|||
* |--------------------------
|
||||
* | b1 b2 ... bs-1 bs
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see ClassicalRungeKuttaIntegrator
|
||||
|
|
|
|||
|
|
@ -37,7 +37,6 @@ import org.apache.commons.math4.util.MathArrays;
|
|||
* |--------------------
|
||||
* | 1/8 3/8 3/8 1/8
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerFieldIntegrator
|
||||
* @see ClassicalRungeKuttaFieldIntegrator
|
||||
|
|
|
|||
|
|
@ -47,7 +47,6 @@ import org.apache.commons.math4.ode.FieldODEStateAndDerivative;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@ package org.apache.commons.math4.ode.nonstiff;
|
|||
* |--------------------
|
||||
* | 1/8 3/8 3/8 1/8
|
||||
* </pre>
|
||||
* </p>
|
||||
*
|
||||
* @see EulerIntegrator
|
||||
* @see ClassicalRungeKuttaIntegrator
|
||||
|
|
|
|||
|
|
@ -44,7 +44,6 @@ import org.apache.commons.math4.ode.sampling.StepInterpolator;
|
|||
* ]
|
||||
* </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* where θ belongs to [0 ; 1] and where y'<sub>1</sub> to y'<sub>4</sub> are the four
|
||||
* evaluations of the derivatives already computed during the
|
||||
|
|
|
|||
|
|
@ -127,10 +127,9 @@
|
|||
* automatic guess is wrong.
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* <table border="1" align="center">
|
||||
* <tr BGCOLOR="#CCCCFF"><td colspan=2><font size="+2">Fixed Step Integrators</font></td></tr>
|
||||
* <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Order</td></font></tr>
|
||||
* <table border="1" style="text-align: center" summary="Fixed Step Integrators">
|
||||
* <tr style="background-color: #CCCCFF"><td colspan=2 style="font-size: x-large">Fixed Step Integrators</td></tr>
|
||||
* <tr style="background-color: #EEEEFF; font-size: larger"><td>Name</td><td>Order</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.EulerIntegrator Euler}</td><td>1</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.MidpointIntegrator Midpoint}</td><td>2</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.ClassicalRungeKuttaIntegrator Classical Runge-Kutta}</td><td>4</td></tr>
|
||||
|
|
@ -138,11 +137,10 @@
|
|||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.ThreeEighthesIntegrator 3/8}</td><td>4</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.LutherIntegrator Luther}</td><td>6</td></tr>
|
||||
* </table>
|
||||
* </p>
|
||||
*
|
||||
* <table border="1" align="center">
|
||||
* <tr BGCOLOR="#CCCCFF"><td colspan=3><font size="+2">Adaptive Stepsize Integrators</font></td></tr>
|
||||
* <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></font></tr>
|
||||
* <table border="1" style="text-align: center" summary="Adaptive Stepsize Integrators">
|
||||
* <tr style="background-color: #CCCCFF"><td colspan=3 style="font-size: x-large">Adaptive Stepsize Integrators</td></tr>
|
||||
* <tr style="background-color: #EEEEFF; font-size: larger"><td>Name</td><td>Integration Order</td><td>Error Estimation Order</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.HighamHall54Integrator Higham and Hall}</td><td>5</td><td>4</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.DormandPrince54Integrator Dormand-Prince 5(4)}</td><td>5</td><td>4</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.DormandPrince853Integrator Dormand-Prince 8(5,3)}</td><td>8</td><td>5 and 3</td></tr>
|
||||
|
|
@ -150,7 +148,6 @@
|
|||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.AdamsBashforthIntegrator Adams-Bashforth}</td><td>variable</td><td>variable</td></tr>
|
||||
* <tr><td>{@link org.apache.commons.math4.ode.nonstiff.AdamsMoultonIntegrator Adams-Moulton}</td><td>variable</td><td>variable</td></tr>
|
||||
* </table>
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* In the table above, the {@link org.apache.commons.math4.ode.nonstiff.AdamsBashforthIntegrator
|
||||
|
|
|
|||
|
|
@ -42,12 +42,11 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* it needs (time steps longer or shorter than the fixed time step and
|
||||
* non-integer ratios are all allowed).</p>
|
||||
*
|
||||
* <p>
|
||||
* <table border="1" align="center">
|
||||
* <tr BGCOLOR="#CCCCFF"><td colspan=6><font size="+2">Examples (step size = 0.5)</font></td></tr>
|
||||
* <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Start time</td><td>End time</td>
|
||||
* <table border="1" style="text-align: center" summary="Examples (step size = 0.5)">
|
||||
* <tr style="background-color: #CCCCFF"><td colspan=6 style="font-size: x-large">Examples (step size = 0.5)</td></tr>
|
||||
* <tr style="background-color: #EEEEFF; font-size: large"><td>Start time</td><td>End time</td>
|
||||
* <td>Direction</td><td>{@link StepNormalizerMode Mode}</td>
|
||||
* <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></font></tr>
|
||||
* <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#NEITHER NEITHER}</td><td>0.8, 1.3, 1.8, 2.3, 2.8</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#FIRST FIRST}</td><td>0.3, 0.8, 1.3, 1.8, 2.3, 2.8</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>0.8, 1.3, 1.8, 2.3, 2.8, 3.1</td></tr>
|
||||
|
|
@ -81,7 +80,6 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr>
|
||||
* <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#BOTH BOTH}</td><td>3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr>
|
||||
* </table>
|
||||
* </p>
|
||||
*
|
||||
* @param <T> the type of the field elements
|
||||
* @see FieldStepHandler
|
||||
|
|
|
|||
|
|
@ -40,12 +40,11 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* it needs (time steps longer or shorter than the fixed time step and
|
||||
* non-integer ratios are all allowed).</p>
|
||||
*
|
||||
* <p>
|
||||
* <table border="1" align="center">
|
||||
* <tr BGCOLOR="#CCCCFF"><td colspan=6><font size="+2">Examples (step size = 0.5)</font></td></tr>
|
||||
* <tr BGCOLOR="#EEEEFF"><font size="+1"><td>Start time</td><td>End time</td>
|
||||
* <table border="1" style="text-align: center" summary="Examples (step size = 0.5)">
|
||||
* <tr style="background-color: #CCCCFF"><td style="font-size: x-large">Examples (step size = 0.5)</td></tr>
|
||||
* <tr style="background-color: #EEEEFF; font-size: large"><td>Start time</td><td>End time</td>
|
||||
* <td>Direction</td><td>{@link StepNormalizerMode Mode}</td>
|
||||
* <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></font></tr>
|
||||
* <td>{@link StepNormalizerBounds Bounds}</td><td>Output</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#NEITHER NEITHER}</td><td>0.8, 1.3, 1.8, 2.3, 2.8</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#FIRST FIRST}</td><td>0.3, 0.8, 1.3, 1.8, 2.3, 2.8</td></tr>
|
||||
* <tr><td>0.3</td><td>3.1</td><td>forward</td><td>{@link StepNormalizerMode#INCREMENT INCREMENT}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>0.8, 1.3, 1.8, 2.3, 2.8, 3.1</td></tr>
|
||||
|
|
@ -79,7 +78,6 @@ import org.apache.commons.numbers.core.Precision;
|
|||
* <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#LAST LAST}</td><td>2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr>
|
||||
* <tr><td>3.0</td><td>0.0</td><td>backward</td><td>{@link StepNormalizerMode#MULTIPLES MULTIPLES}</td><td>{@link StepNormalizerBounds#BOTH BOTH}</td><td>3.0, 2.5, 2.0, 1.5, 1.0, 0.5, 0.0</td></tr>
|
||||
* </table>
|
||||
* </p>
|
||||
*
|
||||
* @see StepHandler
|
||||
* @see FixedStepHandler
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ import org.apache.commons.math4.random.RandomVectorGenerator;
|
|||
|
||||
/**
|
||||
* Base class multi-start optimizer for a multivariate function.
|
||||
* <br/>
|
||||
* <br>
|
||||
* This class wraps an optimizer in order to use it several times in
|
||||
* turn with different starting points (trying to avoid being trapped
|
||||
* in a local extremum when looking for a global one).
|
||||
|
|
@ -101,7 +101,7 @@ public abstract class BaseMultiStartMultivariateOptimizer<PAIR>
|
|||
* restarts. The {@code optimize} method returns the best point only.
|
||||
* This method returns all the points found at the end of each starts,
|
||||
* including the best one already returned by the {@code optimize} method.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The returned array as one element for each start as specified
|
||||
* in the constructor. It is ordered with the results from the
|
||||
* runs that did converge first, sorted from best to worst
|
||||
|
|
@ -112,7 +112,7 @@ public abstract class BaseMultiStartMultivariateOptimizer<PAIR>
|
|||
* an exception.
|
||||
* This also means that if the first element is not {@code null}, it is
|
||||
* the best point found across all starts.
|
||||
* <br/>
|
||||
* <br>
|
||||
* The behaviour is undefined if this method is called before
|
||||
* {@code optimize}; it will likely throw {@code NullPointerException}.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -20,11 +20,11 @@ package org.apache.commons.math4.optim;
|
|||
/**
|
||||
* This interface specifies how to check if an optimization algorithm has
|
||||
* converged.
|
||||
* <br/>
|
||||
* <br>
|
||||
* Deciding if convergence has been reached is a problem-dependent issue. The
|
||||
* user should provide a class implementing this interface to allow the
|
||||
* optimization algorithm to stop its search according to the problem at hand.
|
||||
* <br/>
|
||||
* <br>
|
||||
* For convenience, three implementations that fit simple needs are already
|
||||
* provided: {@link SimpleValueChecker}, {@link SimpleVectorValueChecker} and
|
||||
* {@link SimplePointChecker}. The first two consider that convergence is
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue