-
AdamsMoultonFieldIntegrator
-
METHOD_NAME: String
-
AdamsMoultonFieldIntegrator(Field<RealFieldElement>, int, double, double, double, double): void
-
AdamsMoultonFieldIntegrator(Field<RealFieldElement>, int, double, double, double[], double[]): void
-
integrate(FieldExpandableODE<RealFieldElement>, FieldODEState<RealFieldElement>, RealFieldElement): FieldODEStateAndDerivative<RealFieldElement>
-
Corrector
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math3.ode.nonstiff;
import java.util.Arrays;
import org.apache.commons.math3.Field;
import org.apache.commons.math3.RealFieldElement;
import org.apache.commons.math3.exception.DimensionMismatchException;
import org.apache.commons.math3.exception.MaxCountExceededException;
import org.apache.commons.math3.exception.NoBracketingException;
import org.apache.commons.math3.exception.NumberIsTooSmallException;
import org.apache.commons.math3.linear.Array2DRowFieldMatrix;
import org.apache.commons.math3.linear.FieldMatrixPreservingVisitor;
import org.apache.commons.math3.ode.FieldExpandableODE;
import org.apache.commons.math3.ode.FieldODEState;
import org.apache.commons.math3.ode.FieldODEStateAndDerivative;
import org.apache.commons.math3.util.MathArrays;
import org.apache.commons.math3.util.MathUtils;
This class implements implicit Adams-Moulton integrators for Ordinary
Differential Equations.
Adams-Moulton methods (in fact due to Adams alone) are implicit
multistep ODE solvers. This implementation is a variation of the classical
one: it uses adaptive stepsize to implement error control, whereas
classical implementations are fixed step size. The value of state vector
at step n+1 is a simple combination of the value at step n and of the
derivatives at steps n+1, n, n-1 ... Since y'n+1 is needed to
compute yn+1, another method must be used to compute a first
estimate of yn+1, then compute y'n+1, then compute
a final estimate of yn+1 using the following formulas. Depending
on the number k of previous steps one wants to use for computing the next
value, different formulas are available for the final estimate:
- k = 1: yn+1 = yn + h y'n+1
- k = 2: yn+1 = yn + h (y'n+1+y'n)/2
- k = 3: yn+1 = yn + h (5y'n+1+8y'n-y'n-1)/12
- k = 4: yn+1 = yn + h (9y'n+1+19y'n-5y'n-1+y'n-2)/24
- ...
A k-steps Adams-Moulton method is of order k+1.
Implementation details
We define scaled derivatives si(n) at step n as:
s1(n) = h y'n for first derivative
s2(n) = h2/2 y''n for second derivative
s3(n) = h3/6 y'''n for third derivative
...
sk(n) = hk/k! y(k)n for kth derivative
The definitions above use the classical representation with several previous first
derivatives. Lets define
qn = [ s1(n-1) s1(n-2) ... s1(n-(k-1)) ]T
(we omit the k index in the notation for clarity). With these definitions,
Adams-Moulton methods can be written:
- k = 1: yn+1 = yn + s1(n+1)
- k = 2: yn+1 = yn + 1/2 s1(n+1) + [ 1/2 ] qn+1
- k = 3: yn+1 = yn + 5/12 s1(n+1) + [ 8/12 -1/12 ] qn+1
- k = 4: yn+1 = yn + 9/24 s1(n+1) + [ 19/24 -5/24 1/24 ] qn+1
- ...
Instead of using the classical representation with first derivatives only (yn,
s1(n+1) and qn+1), our implementation uses the Nordsieck vector with
higher degrees scaled derivatives all taken at the same step (yn, s1(n)
and rn) where rn is defined as:
rn = [ s2(n), s3(n) ... sk(n) ]T
(here again we omit the k index in the notation for clarity)
Taylor series formulas show that for any index offset i, s1(n-i) can be
computed from s1(n), s2(n) ... sk(n), the formula being exact
for degree k polynomials.
s1(n-i) = s1(n) + ∑j>0 (j+1) (-i)j sj+1(n)
The previous formula can be used with several values for i to compute the transform between
classical representation and Nordsieck vector. The transform between rn
and qn resulting from the Taylor series formulas above is:
qn = s1(n) u + P rn
where u is the [ 1 1 ... 1 ]T vector and P is the (k-1)×(k-1) matrix built
with the (j+1) (-i)j terms with i being the row number starting from 1 and j being
the column number starting from 1:
[ -2 3 -4 5 ... ]
[ -4 12 -32 80 ... ]
P = [ -6 27 -108 405 ... ]
[ -8 48 -256 1280 ... ]
[ ... ]
Using the Nordsieck vector has several advantages:
- it greatly simplifies step interpolation as the interpolator mainly applies
Taylor series formulas,
- it simplifies step changes that occur when discrete events that truncate
the step are triggered,
- it allows to extend the methods in order to support adaptive stepsize.
The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step
n as follows:
- Yn+1 = yn + s1(n) + uT rn
- S1(n+1) = h f(tn+1, Yn+1)
- Rn+1 = (s1(n) - S1(n+1)) P-1 u + P-1 A P rn
where A is a rows shifting matrix (the lower left part is an identity matrix):
[ 0 0 ... 0 0 | 0 ]
[ ---------------+---]
[ 1 0 ... 0 0 | 0 ]
A = [ 0 1 ... 0 0 | 0 ]
[ ... | 0 ]
[ 0 0 ... 1 0 | 0 ]
[ 0 0 ... 0 1 | 0 ]
From this predicted vector, the corrected vector is computed as follows:
- yn+1 = yn + S1(n+1) + [ -1 +1 -1 +1 ... ±1 ] rn+1
- s1(n+1) = h f(tn+1, yn+1)
- rn+1 = Rn+1 + (s1(n+1) - S1(n+1)) P-1 u
where the upper case Yn+1, S1(n+1) and Rn+1 represent the
predicted states whereas the lower case yn+1, sn+1 and rn+1
represent the corrected states.
The P-1u vector and the P-1 A P matrix do not depend on the state,
they only depend on k and therefore are precomputed once for all.
Type parameters: - <T> – the type of the field elements
Since: 3.6
/**
* This class implements implicit Adams-Moulton integrators for Ordinary
* Differential Equations.
*
* <p>Adams-Moulton methods (in fact due to Adams alone) are implicit
* multistep ODE solvers. This implementation is a variation of the classical
* one: it uses adaptive stepsize to implement error control, whereas
* classical implementations are fixed step size. The value of state vector
* at step n+1 is a simple combination of the value at step n and of the
* derivatives at steps n+1, n, n-1 ... Since y'<sub>n+1</sub> is needed to
* compute y<sub>n+1</sub>, another method must be used to compute a first
* estimate of y<sub>n+1</sub>, then compute y'<sub>n+1</sub>, then compute
* a final estimate of y<sub>n+1</sub> using the following formulas. Depending
* on the number k of previous steps one wants to use for computing the next
* value, different formulas are available for the final estimate:</p>
* <ul>
* <li>k = 1: y<sub>n+1</sub> = y<sub>n</sub> + h y'<sub>n+1</sub></li>
* <li>k = 2: y<sub>n+1</sub> = y<sub>n</sub> + h (y'<sub>n+1</sub>+y'<sub>n</sub>)/2</li>
* <li>k = 3: y<sub>n+1</sub> = y<sub>n</sub> + h (5y'<sub>n+1</sub>+8y'<sub>n</sub>-y'<sub>n-1</sub>)/12</li>
* <li>k = 4: y<sub>n+1</sub> = y<sub>n</sub> + h (9y'<sub>n+1</sub>+19y'<sub>n</sub>-5y'<sub>n-1</sub>+y'<sub>n-2</sub>)/24</li>
* <li>...</li>
* </ul>
*
* <p>A k-steps Adams-Moulton method is of order k+1.</p>
*
* <h3>Implementation details</h3>
*
* <p>We define scaled derivatives s<sub>i</sub>(n) at step n as:
* <pre>
* 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>
*
* <p>The definitions above use the classical representation with several previous first
* derivatives. Lets define
* <pre>
* 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). With these definitions,
* Adams-Moulton methods can be written:
* <ul>
* <li>k = 1: y<sub>n+1</sub> = y<sub>n</sub> + s<sub>1</sub>(n+1)</li>
* <li>k = 2: y<sub>n+1</sub> = y<sub>n</sub> + 1/2 s<sub>1</sub>(n+1) + [ 1/2 ] q<sub>n+1</sub></li>
* <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>
*
* <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>
* r<sub>n</sub> = [ s<sub>2</sub>(n), s<sub>3</sub>(n) ... s<sub>k</sub>(n) ]<sup>T</sup>
* </pre>
* (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>
* 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>
* 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>
* q<sub>n</sub> = s<sub>1</sub>(n) u + P r<sub>n</sub>
* </pre>
* 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:
* <pre>
* [ -2 3 -4 5 ... ]
* [ -4 12 -32 80 ... ]
* P = [ -6 27 -108 405 ... ]
* [ -8 48 -256 1280 ... ]
* [ ... ]
* </pre></p>
*
* <p>Using the Nordsieck vector has several advantages:
* <ul>
* <li>it greatly simplifies step interpolation as the interpolator mainly applies
* Taylor series formulas,</li>
* <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>
*
* <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step
* n as follows:
* <ul>
* <li>Y<sub>n+1</sub> = y<sub>n</sub> + s<sub>1</sub>(n) + u<sup>T</sup> r<sub>n</sub></li>
* <li>S<sub>1</sub>(n+1) = h f(t<sub>n+1</sub>, Y<sub>n+1</sub>)</li>
* <li>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></li>
* </ul>
* where A is a rows shifting matrix (the lower left part is an identity matrix):
* <pre>
* [ 0 0 ... 0 0 | 0 ]
* [ ---------------+---]
* [ 1 0 ... 0 0 | 0 ]
* A = [ 0 1 ... 0 0 | 0 ]
* [ ... | 0 ]
* [ 0 0 ... 1 0 | 0 ]
* [ 0 0 ... 0 1 | 0 ]
* </pre>
* From this predicted vector, the corrected vector is computed as follows:
* <ul>
* <li>y<sub>n+1</sub> = y<sub>n</sub> + S<sub>1</sub>(n+1) + [ -1 +1 -1 +1 ... ±1 ] r<sub>n+1</sub></li>
* <li>s<sub>1</sub>(n+1) = h f(t<sub>n+1</sub>, y<sub>n+1</sub>)</li>
* <li>r<sub>n+1</sub> = R<sub>n+1</sub> + (s<sub>1</sub>(n+1) - S<sub>1</sub>(n+1)) P<sup>-1</sup> u</li>
* </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>
*
* <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>
*
* @param <T> the type of the field elements
* @since 3.6
*/
public class AdamsMoultonFieldIntegrator<T extends RealFieldElement<T>> extends AdamsFieldIntegrator<T> {
Integrator method name. /** Integrator method name. */
private static final String METHOD_NAME = "Adams-Moulton";
Build an Adams-Moulton integrator with the given order and error control parameters.
Params: - field – field to which the time and state vector elements belong
- nSteps – number of steps of the method excluding the one being computed
- minStep – minimal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than this
- maxStep – maximal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than this
- scalAbsoluteTolerance – allowed absolute error
- scalRelativeTolerance – allowed relative error
Throws: - NumberIsTooSmallException – if order is 1 or less
/**
* Build an Adams-Moulton integrator with the given order and error control parameters.
* @param field field to which the time and state vector elements belong
* @param nSteps number of steps of the method excluding the one being computed
* @param minStep minimal step (sign is irrelevant, regardless of
* integration direction, forward or backward), the last step can
* be smaller than this
* @param maxStep maximal step (sign is irrelevant, regardless of
* integration direction, forward or backward), the last step can
* be smaller than this
* @param scalAbsoluteTolerance allowed absolute error
* @param scalRelativeTolerance allowed relative error
* @exception NumberIsTooSmallException if order is 1 or less
*/
public AdamsMoultonFieldIntegrator(final Field<T> field, final int nSteps,
final double minStep, final double maxStep,
final double scalAbsoluteTolerance,
final double scalRelativeTolerance)
throws NumberIsTooSmallException {
super(field, METHOD_NAME, nSteps, nSteps + 1, minStep, maxStep,
scalAbsoluteTolerance, scalRelativeTolerance);
}
Build an Adams-Moulton integrator with the given order and error control parameters.
Params: - field – field to which the time and state vector elements belong
- nSteps – number of steps of the method excluding the one being computed
- minStep – minimal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than this
- maxStep – maximal step (sign is irrelevant, regardless of
integration direction, forward or backward), the last step can
be smaller than this
- vecAbsoluteTolerance – allowed absolute error
- vecRelativeTolerance – allowed relative error
Throws: - IllegalArgumentException – if order is 1 or less
/**
* Build an Adams-Moulton integrator with the given order and error control parameters.
* @param field field to which the time and state vector elements belong
* @param nSteps number of steps of the method excluding the one being computed
* @param minStep minimal step (sign is irrelevant, regardless of
* integration direction, forward or backward), the last step can
* be smaller than this
* @param maxStep maximal step (sign is irrelevant, regardless of
* integration direction, forward or backward), the last step can
* be smaller than this
* @param vecAbsoluteTolerance allowed absolute error
* @param vecRelativeTolerance allowed relative error
* @exception IllegalArgumentException if order is 1 or less
*/
public AdamsMoultonFieldIntegrator(final Field<T> field, final int nSteps,
final double minStep, final double maxStep,
final double[] vecAbsoluteTolerance,
final double[] vecRelativeTolerance)
throws IllegalArgumentException {
super(field, METHOD_NAME, nSteps, nSteps + 1, minStep, maxStep,
vecAbsoluteTolerance, vecRelativeTolerance);
}
{@inheritDoc} /** {@inheritDoc} */
@Override
public FieldODEStateAndDerivative<T> integrate(final FieldExpandableODE<T> equations,
final FieldODEState<T> initialState,
final T finalTime)
throws NumberIsTooSmallException, DimensionMismatchException,
MaxCountExceededException, NoBracketingException {
sanityChecks(initialState, finalTime);
final T t0 = initialState.getTime();
final T[] y = equations.getMapper().mapState(initialState);
setStepStart(initIntegration(equations, t0, y, finalTime));
final boolean forward = finalTime.subtract(initialState.getTime()).getReal() > 0;
// compute the initial Nordsieck vector using the configured starter integrator
start(equations, getStepStart(), finalTime);
// reuse the step that was chosen by the starter integrator
FieldODEStateAndDerivative<T> stepStart = getStepStart();
FieldODEStateAndDerivative<T> stepEnd =
AdamsFieldStepInterpolator.taylor(stepStart,
stepStart.getTime().add(getStepSize()),
getStepSize(), scaled, nordsieck);
// main integration loop
setIsLastStep(false);
do {
T[] predictedY = null;
final T[] predictedScaled = MathArrays.buildArray(getField(), y.length);
Array2DRowFieldMatrix<T> predictedNordsieck = null;
T error = getField().getZero().add(10);
while (error.subtract(1.0).getReal() >= 0.0) {
// predict a first estimate of the state at step end (P in the PECE sequence)
predictedY = stepEnd.getState();
// evaluate a first estimate of the derivative (first E in the PECE sequence)
final T[] yDot = computeDerivatives(stepEnd.getTime(), predictedY);
// update Nordsieck vector
for (int j = 0; j < predictedScaled.length; ++j) {
predictedScaled[j] = getStepSize().multiply(yDot[j]);
}
predictedNordsieck = updateHighOrderDerivativesPhase1(nordsieck);
updateHighOrderDerivativesPhase2(scaled, predictedScaled, predictedNordsieck);
// apply correction (C in the PECE sequence)
error = predictedNordsieck.walkInOptimizedOrder(new Corrector(y, predictedScaled, predictedY));
if (error.subtract(1.0).getReal() >= 0.0) {
// reject the step and attempt to reduce error by stepsize control
final T factor = computeStepGrowShrinkFactor(error);
rescale(filterStep(getStepSize().multiply(factor), forward, false));
stepEnd = AdamsFieldStepInterpolator.taylor(getStepStart(),
getStepStart().getTime().add(getStepSize()),
getStepSize(),
scaled,
nordsieck);
}
}
// evaluate a final estimate of the derivative (second E in the PECE sequence)
final T[] correctedYDot = computeDerivatives(stepEnd.getTime(), predictedY);
// update Nordsieck vector
final T[] correctedScaled = MathArrays.buildArray(getField(), y.length);
for (int j = 0; j < correctedScaled.length; ++j) {
correctedScaled[j] = getStepSize().multiply(correctedYDot[j]);
}
updateHighOrderDerivativesPhase2(predictedScaled, correctedScaled, predictedNordsieck);
// discrete events handling
stepEnd = new FieldODEStateAndDerivative<T>(stepEnd.getTime(), predictedY, correctedYDot);
setStepStart(acceptStep(new AdamsFieldStepInterpolator<T>(getStepSize(), stepEnd,
correctedScaled, predictedNordsieck, forward,
getStepStart(), stepEnd,
equations.getMapper()),
finalTime));
scaled = correctedScaled;
nordsieck = predictedNordsieck;
if (!isLastStep()) {
System.arraycopy(predictedY, 0, y, 0, y.length);
if (resetOccurred()) {
// some events handler has triggered changes that
// invalidate the derivatives, we need to restart from scratch
start(equations, getStepStart(), finalTime);
}
// stepsize control for next step
final T factor = computeStepGrowShrinkFactor(error);
final T scaledH = getStepSize().multiply(factor);
final T nextT = getStepStart().getTime().add(scaledH);
final boolean nextIsLast = forward ?
nextT.subtract(finalTime).getReal() >= 0 :
nextT.subtract(finalTime).getReal() <= 0;
T hNew = filterStep(scaledH, forward, nextIsLast);
final T filteredNextT = getStepStart().getTime().add(hNew);
final boolean filteredNextIsLast = forward ?
filteredNextT.subtract(finalTime).getReal() >= 0 :
filteredNextT.subtract(finalTime).getReal() <= 0;
if (filteredNextIsLast) {
hNew = finalTime.subtract(getStepStart().getTime());
}
rescale(hNew);
stepEnd = AdamsFieldStepInterpolator.taylor(getStepStart(), getStepStart().getTime().add(getStepSize()),
getStepSize(), scaled, nordsieck);
}
} while (!isLastStep());
final FieldODEStateAndDerivative<T> finalState = getStepStart();
setStepStart(null);
setStepSize(null);
return finalState;
}
Corrector for current state in Adams-Moulton method.
This visitor implements the Taylor series formula:
Yn+1 = yn + s1(n+1) + [ -1 +1 -1 +1 ... ±1 ] rn+1
/** Corrector for current state in Adams-Moulton method.
* <p>
* This visitor implements the Taylor series formula:
* <pre>
* Y<sub>n+1</sub> = y<sub>n</sub> + s<sub>1</sub>(n+1) + [ -1 +1 -1 +1 ... ±1 ] r<sub>n+1</sub>
* </pre>
* </p>
*/
private class Corrector implements FieldMatrixPreservingVisitor<T> {
Previous state. /** Previous state. */
private final T[] previous;
Current scaled first derivative. /** Current scaled first derivative. */
private final T[] scaled;
Current state before correction. /** Current state before correction. */
private final T[] before;
Current state after correction. /** Current state after correction. */
private final T[] after;
Simple constructor.
Params: - previous – previous state
- scaled – current scaled first derivative
- state – state to correct (will be overwritten after visit)
/** Simple constructor.
* @param previous previous state
* @param scaled current scaled first derivative
* @param state state to correct (will be overwritten after visit)
*/
Corrector(final T[] previous, final T[] scaled, final T[] state) {
this.previous = previous;
this.scaled = scaled;
this.after = state;
this.before = state.clone();
}
{@inheritDoc} /** {@inheritDoc} */
public void start(int rows, int columns,
int startRow, int endRow, int startColumn, int endColumn) {
Arrays.fill(after, getField().getZero());
}
{@inheritDoc} /** {@inheritDoc} */
public void visit(int row, int column, T value) {
if ((row & 0x1) == 0) {
after[column] = after[column].subtract(value);
} else {
after[column] = after[column].add(value);
}
}
End visiting the Nordsieck vector.
The correction is used to control stepsize. So its amplitude is
considered to be an error, which must be normalized according to
error control settings. If the normalized value is greater than 1,
the correction was too large and the step must be rejected.
Returns: the normalized correction, if greater than 1, the step
must be rejected
/**
* End visiting the Nordsieck vector.
* <p>The correction is used to control stepsize. So its amplitude is
* considered to be an error, which must be normalized according to
* error control settings. If the normalized value is greater than 1,
* the correction was too large and the step must be rejected.</p>
* @return the normalized correction, if greater than 1, the step
* must be rejected
*/
public T end() {
T error = getField().getZero();
for (int i = 0; i < after.length; ++i) {
after[i] = after[i].add(previous[i].add(scaled[i]));
if (i < mainSetDimension) {
final T yScale = MathUtils.max(previous[i].abs(), after[i].abs());
final T tol = (vecAbsoluteTolerance == null) ?
yScale.multiply(scalRelativeTolerance).add(scalAbsoluteTolerance) :
yScale.multiply(vecRelativeTolerance[i]).add(vecAbsoluteTolerance[i]);
final T ratio = after[i].subtract(before[i]).divide(tol); // (corrected-predicted)/tol
error = error.add(ratio.multiply(ratio));
}
}
return error.divide(mainSetDimension).sqrt();
}
}
}