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

Java example source code file (AdamsMoultonIntegrator.java)

This example Java source code file (AdamsMoultonIntegrator.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

adamsintegrator, adamsmoultonintegrator, array2drowrealmatrix, corrector, equationsmapper, expandablestatefulode, illegalargumentexception, maxcountexceededexception, method_name, nobracketingexception, nordsieckstepinterpolator, numberistoosmallexception, override, string, util

The AdamsMoultonIntegrator.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.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.Array2DRowRealMatrix;
import org.apache.commons.math3.linear.RealMatrixPreservingVisitor;
import org.apache.commons.math3.ode.EquationsMapper;
import org.apache.commons.math3.ode.ExpandableStatefulODE;
import org.apache.commons.math3.ode.sampling.NordsieckStepInterpolator;
import org.apache.commons.math3.util.FastMath;


/**
 * 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> * * @since 2.0 */ public class AdamsMoultonIntegrator extends AdamsIntegrator { /** 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 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 AdamsMoultonIntegrator(final int nSteps, final double minStep, final double maxStep, final double scalAbsoluteTolerance, final double scalRelativeTolerance) throws NumberIsTooSmallException { super(METHOD_NAME, nSteps, nSteps + 1, minStep, maxStep, scalAbsoluteTolerance, scalRelativeTolerance); } /** * Build an Adams-Moulton integrator with the given order and error control parameters. * @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 AdamsMoultonIntegrator(final int nSteps, final double minStep, final double maxStep, final double[] vecAbsoluteTolerance, final double[] vecRelativeTolerance) throws IllegalArgumentException { super(METHOD_NAME, nSteps, nSteps + 1, minStep, maxStep, vecAbsoluteTolerance, vecRelativeTolerance); } /** {@inheritDoc} */ @Override public void integrate(final ExpandableStatefulODE equations,final double t) throws NumberIsTooSmallException, DimensionMismatchException, MaxCountExceededException, NoBracketingException { sanityChecks(equations, t); setEquations(equations); final boolean forward = t > equations.getTime(); // initialize working arrays final double[] y0 = equations.getCompleteState(); final double[] y = y0.clone(); final double[] yDot = new double[y.length]; final double[] yTmp = new double[y.length]; final double[] predictedScaled = new double[y.length]; Array2DRowRealMatrix nordsieckTmp = null; // set up two interpolators sharing the integrator arrays final NordsieckStepInterpolator interpolator = new NordsieckStepInterpolator(); interpolator.reinitialize(y, forward, equations.getPrimaryMapper(), equations.getSecondaryMappers()); // set up integration control objects initIntegration(equations.getTime(), y0, t); // compute the initial Nordsieck vector using the configured starter integrator start(equations.getTime(), y, t); interpolator.reinitialize(stepStart, stepSize, scaled, nordsieck); interpolator.storeTime(stepStart); double hNew = stepSize; interpolator.rescale(hNew); isLastStep = false; do { double error = 10; while (error >= 1.0) { stepSize = hNew; // predict a first estimate of the state at step end (P in the PECE sequence) final double stepEnd = stepStart + stepSize; interpolator.setInterpolatedTime(stepEnd); final ExpandableStatefulODE expandable = getExpandable(); final EquationsMapper primary = expandable.getPrimaryMapper(); primary.insertEquationData(interpolator.getInterpolatedState(), yTmp); int index = 0; for (final EquationsMapper secondary : expandable.getSecondaryMappers()) { secondary.insertEquationData(interpolator.getInterpolatedSecondaryState(index), yTmp); ++index; } // evaluate a first estimate of the derivative (first E in the PECE sequence) computeDerivatives(stepEnd, yTmp, yDot); // update Nordsieck vector for (int j = 0; j < y0.length; ++j) { predictedScaled[j] = stepSize * yDot[j]; } nordsieckTmp = updateHighOrderDerivativesPhase1(nordsieck); updateHighOrderDerivativesPhase2(scaled, predictedScaled, nordsieckTmp); // apply correction (C in the PECE sequence) error = nordsieckTmp.walkInOptimizedOrder(new Corrector(y, predictedScaled, yTmp)); if (error >= 1.0) { // reject the step and attempt to reduce error by stepsize control final double factor = computeStepGrowShrinkFactor(error); hNew = filterStep(stepSize * factor, forward, false); interpolator.rescale(hNew); } } // evaluate a final estimate of the derivative (second E in the PECE sequence) final double stepEnd = stepStart + stepSize; computeDerivatives(stepEnd, yTmp, yDot); // update Nordsieck vector final double[] correctedScaled = new double[y0.length]; for (int j = 0; j < y0.length; ++j) { correctedScaled[j] = stepSize * yDot[j]; } updateHighOrderDerivativesPhase2(predictedScaled, correctedScaled, nordsieckTmp); // discrete events handling System.arraycopy(yTmp, 0, y, 0, y.length); interpolator.reinitialize(stepEnd, stepSize, correctedScaled, nordsieckTmp); interpolator.storeTime(stepStart); interpolator.shift(); interpolator.storeTime(stepEnd); stepStart = acceptStep(interpolator, y, yDot, t); scaled = correctedScaled; nordsieck = nordsieckTmp; if (!isLastStep) { // prepare next step interpolator.storeTime(stepStart); if (resetOccurred) { // some events handler has triggered changes that // invalidate the derivatives, we need to restart from scratch start(stepStart, y, t); interpolator.reinitialize(stepStart, stepSize, scaled, nordsieck); } // stepsize control for next step final double factor = computeStepGrowShrinkFactor(error); final double scaledH = stepSize * factor; final double nextT = stepStart + scaledH; final boolean nextIsLast = forward ? (nextT >= t) : (nextT <= t); hNew = filterStep(scaledH, forward, nextIsLast); final double filteredNextT = stepStart + hNew; final boolean filteredNextIsLast = forward ? (filteredNextT >= t) : (filteredNextT <= t); if (filteredNextIsLast) { hNew = t - stepStart; } interpolator.rescale(hNew); } } while (!isLastStep); // dispatch results equations.setTime(stepStart); equations.setCompleteState(y); resetInternalState(); } /** 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 RealMatrixPreservingVisitor { /** Previous state. */ private final double[] previous; /** Current scaled first derivative. */ private final double[] scaled; /** Current state before correction. */ private final double[] before; /** Current state after correction. */ private final double[] 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 double[] previous, final double[] scaled, final double[] 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, 0.0); } /** {@inheritDoc} */ public void visit(int row, int column, double value) { if ((row & 0x1) == 0) { after[column] -= value; } else { after[column] += 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 double end() { double error = 0; for (int i = 0; i < after.length; ++i) { after[i] += previous[i] + scaled[i]; if (i < mainSetDimension) { final double yScale = FastMath.max(FastMath.abs(previous[i]), FastMath.abs(after[i])); final double tol = (vecAbsoluteTolerance == null) ? (scalAbsoluteTolerance + scalRelativeTolerance * yScale) : (vecAbsoluteTolerance[i] + vecRelativeTolerance[i] * yScale); final double ratio = (after[i] - before[i]) / tol; // (corrected-predicted)/tol error += ratio * ratio; } } return FastMath.sqrt(error / mainSetDimension); } } }

Other Java examples (source code examples)

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



my book on functional programming

 

new blog posts

 

Copyright 1998-2019 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.