This class is used by Adams-Bashforth and
Adams-Moulton integrators to convert between
classical representation with several previous first derivatives and Nordsieck
representation with higher order scaled derivatives.
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
With the previous definition, the classical representation of multistep methods uses first derivatives only, i.e. it handles yn, s1(n) and qn where qn is defined as:
qn = [ s1(n-1) s1(n-2) ... s1(n-(k-1)) ]T(we omit the k index in the notation for clarity).
Another possible representation uses the Nordsieck vector with higher degrees scaled derivatives all taken at the same step, i.e it handles 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 at step end. The transform between rn and qn resulting from the Taylor series formulas above is:
qn = s1(n) u + P rnwhere 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 ... ]
[ ... ]
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 the absolute value of matrix P.
For Adams-Bashforth method, the Nordsieck vector
at step n+1 is computed from the Nordsieck vector at step n as follows:
[ 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 ]
For Adams-Moulton method, the predicted Nordsieck vector
at step n+1 is computed from the Nordsieck vector at step n as follows:
We observe that both methods use similar update formulas. In both cases a P-1u vector and a P-1 A P matrix are used that do not depend on the state, they only depend on k. This class handles these transformations.
| Modifier and Type | Field and Description |
|---|---|
| private final double[] | c1
Update coefficients of the higher order derivatives wrt y'. |
| private static final Map | CACHE
Cache for already computed coefficients. |
| private final Array2DRowRealMatrix | update
Update matrix for the higher order derivatives h2/2 y'', h3/6 y''' ... |
| Access | Constructor and Description |
|---|---|
| private | AdamsNordsieckTransformer(final int
number of steps of the multistep method
(excluding the one being computed) n)Simple constructor. |
| Modifier and Type | Method and Description |
|---|---|
| private FieldMatrix | |
| public static AdamsNordsieckTransformer | Returns: Nordsieck transformer for the specified number of stepsnumber of steps of the multistep method
(excluding the one being computed) nSteps)Get the Nordsieck transformer for a given number of steps. |
| public int | Returns: number of steps of the method (excluding the one being computed)
Deprecated
as of 3.6, this method is not used anymore
Get the number of steps of the method (excluding the one being computed). |
| public Array2DRowRealMatrix | Returns: Nordieck vector at start of first step (h2/2 y''n, h3/6 y'''n ... hk/k! y(k)n)step size to use for scaling h, final double[] first steps times t, final double[][] first steps states y, final double[][] first steps derivatives yDot)Initialize the high order scaled derivatives at step start. |
| public Array2DRowRealMatrix | Returns: updated high order derivativeshigh order scaled derivatives
(h2/2 y'', ... hk/k! y(k)) highOrder)Update the high order scaled derivatives for Adams integrators (phase 1). |
| public void | updateHighOrderDerivativesPhase2(final double[]
first order scaled derivatives at step start start, final double[] first order scaled derivatives at step end end, final Array2DRowRealMatrix high order scaled derivatives, will be modified
(h2/2 y'', ... hk/k! y(k)) highOrder)Update the high order scaled derivatives Adams integrators (phase 2). |
| c1 | back to summary |
|---|---|
| private final double[] c1 Update coefficients of the higher order derivatives wrt y'. | |
| CACHE | back to summary |
|---|---|
| private static final Map<Integer, AdamsNordsieckTransformer> CACHE Cache for already computed coefficients. | |
| update | back to summary |
|---|---|
| private final Array2DRowRealMatrix update Update matrix for the higher order derivatives h2/2 y'', h3/6 y''' ... | |
| AdamsNordsieckTransformer | back to summary |
|---|---|
| private AdamsNordsieckTransformer(final int n) Simple constructor.
| |
| buildP | back to summary |
|---|---|
| private FieldMatrix Build the P matrix. The P matrix general terms are shifted (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 ... ]
[ ... ]
| |
| getInstance | back to summary |
|---|---|
| public static AdamsNordsieckTransformer getInstance(final int nSteps) Get the Nordsieck transformer for a given number of steps.
| |
| getNSteps | back to summary |
|---|---|
| public int getNSteps()
Deprecated as of 3.6, this method is not used anymore Get the number of steps of the method (excluding the one being computed).
| |
| initializeHighOrderDerivatives | back to summary |
|---|---|
| public Array2DRowRealMatrix initializeHighOrderDerivatives(final double h, final double[] t, final double[][] y, final double[][] yDot) Initialize the high order scaled derivatives at step start.
| |
| updateHighOrderDerivativesPhase1 | back to summary |
|---|---|
| public Array2DRowRealMatrix updateHighOrderDerivativesPhase1(final Array2DRowRealMatrix highOrder) Update the high order scaled derivatives for Adams integrators (phase 1). The complete update of high order derivatives has a form similar to: rn+1 = (s1(n) - s1(n+1)) P-1 u + P-1 A P rnthis method computes the P-1 A P rn part.
| |
| updateHighOrderDerivativesPhase2 | back to summary |
|---|---|
| public void updateHighOrderDerivativesPhase2(final double[] start, final double[] end, final Array2DRowRealMatrix highOrder) Update the high order scaled derivatives Adams integrators (phase 2). The complete update of high order derivatives has a form similar to: rn+1 = (s1(n) - s1(n+1)) P-1 u + P-1 A P rnthis method computes the (s1(n) - s1(n+1)) P-1 u part. Phase 1 of the update must already have been performed.
| |