home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (AdamsMoultonFieldIntegrator.java)

This example Java source code file (AdamsMoultonFieldIntegrator.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

adamsfieldstepinterpolator, adamsmoultonfieldintegrator, array2drowfieldmatrix, corrector, fieldexpandableode, fieldmatrixpreservingvisitor, fieldodestateandderivative, illegalargumentexception, maxcountexceededexception, method_name, nobracketingexception, numberistoosmallexception, override, util

The AdamsMoultonFieldIntegrator.java Java example source code

/*
 * 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.
 *
 * <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 is needed to
 * compute y<sub>n+1, another method must be used to compute a first
 * estimate of y<sub>n+1, then compute y'n+1, then compute
 * a final estimate of y<sub>n+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:</p>
 * <ul>
 *   <li>k = 1: yn+1 = yn + h y'n+1
 *   <li>k = 2: yn+1 = yn + h (y'n+1+y'n)/2
 *   <li>k = 3: yn+1 = yn + h (5y'n+1+8y'n-y'n-1)/12
 *   <li>k = 4: yn+1 = yn + h (9y'n+1+19y'n-5y'n-1+y'n-2)/24
 *   <li>...
 * </ul>
 *
 * <p>A k-steps Adams-Moulton method is of order k+1.

* * <h3>Implementation details * * <p>We define scaled derivatives si(n) at step n as: * <pre> * s<sub>1(n) = h y'n for first derivative * s<sub>2(n) = h2/2 y''n for second derivative * s<sub>3(n) = h3/6 y'''n for third derivative * ... * s<sub>k(n) = hk/k! y(k)n for kth derivative * </pre>

* * <p>The definitions above use the classical representation with several previous first * derivatives. Lets define * <pre> * q<sub>n = [ s1(n-1) s1(n-2) ... s1(n-(k-1)) ]T * </pre> * (we omit the k index in the notation for clarity). With these definitions, * Adams-Moulton methods can be written: * <ul> * <li>k = 1: yn+1 = yn + s1(n+1) * <li>k = 2: yn+1 = yn + 1/2 s1(n+1) + [ 1/2 ] qn+1 * <li>k = 3: yn+1 = yn + 5/12 s1(n+1) + [ 8/12 -1/12 ] qn+1 * <li>k = 4: yn+1 = yn + 9/24 s1(n+1) + [ 19/24 -5/24 1/24 ] qn+1 * <li>... * </ul>

* * <p>Instead of using the classical representation with first derivatives only (yn, * s<sub>1(n+1) and qn+1), our implementation uses the Nordsieck vector with * higher degrees scaled derivatives all taken at the same step (y<sub>n, s1(n) * and r<sub>n) where rn is defined as: * <pre> * r<sub>n = [ s2(n), s3(n) ... sk(n) ]T * </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, s1(n-i) can be * computed from s<sub>1(n), s2(n) ... sk(n), the formula being exact * for degree k polynomials. * <pre> * s<sub>1(n-i) = s1(n) + ∑j>0 (j+1) (-i)j sj+1(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 * and q<sub>n resulting from the Taylor series formulas above is: * <pre> * q<sub>n = s1(n) u + P rn * </pre> * where u is the [ 1 1 ... 1 ]<sup>T vector and P is the (k-1)×(k-1) matrix built * with the (j+1) (-i)<sup>j 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>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. * </ul>

* * <p>The predicted Nordsieck vector at step n+1 is computed from the Nordsieck vector at step * n as follows: * <ul> * <li>Yn+1 = yn + s1(n) + uT rn * <li>S1(n+1) = h f(tn+1, Yn+1) * <li>Rn+1 = (s1(n) - S1(n+1)) P-1 u + P-1 A P rn * </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>yn+1 = yn + S1(n+1) + [ -1 +1 -1 +1 ... ±1 ] rn+1 * <li>s1(n+1) = h f(tn+1, yn+1) * <li>rn+1 = Rn+1 + (s1(n+1) - S1(n+1)) P-1 u * </ul> * where the upper case Y<sub>n+1, S1(n+1) and Rn+1 represent the * predicted states whereas the lower case y<sub>n+1, sn+1 and rn+1 * represent the corrected states.</p> * * <p>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.</p> * * @param <T> the type of the field elements * @since 3.6 */ public class AdamsMoultonFieldIntegrator<T extends RealFieldElement extends AdamsFieldIntegrator { /** Integrator method name. */ private static final String METHOD_NAME = "Adams-Moulton"; /** * 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. * @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} */ @Override public FieldODEStateAndDerivative<T> integrate(final FieldExpandableODE 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. * <p> * This visitor implements the Taylor series formula: * <pre> * Y<sub>n+1 = yn + s1(n+1) + [ -1 +1 -1 +1 ... ±1 ] rn+1 * </pre> * </p> */ private class Corrector implements FieldMatrixPreservingVisitor<T> { /** Previous state. */ private final T[] previous; /** Current scaled first derivative. */ private final T[] scaled; /** Current state before correction. */ private final T[] before; /** Current state after correction. */ private final T[] after; /** 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} */ public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) { Arrays.fill(after, getField().getZero()); } /** {@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. * <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(); } } }

Other Java examples (source code examples)

Here is a short list of links related to this Java AdamsMoultonFieldIntegrator.java source code file:



my book on functional programming

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.