程序包 org.hipparchus.ode.nonstiff

类 AdamsMoultonFieldIntegrator<T extends CalculusFieldElement<T>>

java.lang.Object
org.hipparchus.ode.AbstractFieldIntegrator<T>
org.hipparchus.ode.nonstiff.AdaptiveStepsizeFieldIntegrator<T>
org.hipparchus.ode.MultistepFieldIntegrator<T>
org.hipparchus.ode.nonstiff.AdamsFieldIntegrator<T>
org.hipparchus.ode.nonstiff.AdamsMoultonFieldIntegrator<T>
类型参数:
T - 字段元素的类型
所有已实现的接口:
FieldODEIntegrator<T>
public class AdamsMoultonFieldIntegrator<T extends CalculusFieldElement<T>> extends AdamsFieldIntegrator<T>
该类实现了用于常微分方程的隐式Adams-Moulton积分器。

Adams-Moulton方法（实际上仅由Adams提出）是隐式多步ODE求解器。此实现是经典实现的变体：它使用自适应步长来实现误差控制，而经典实现是固定步长。第n+1步的状态向量的值是第n步的值和第n+1、n、n-1步的导数的简单组合。由于需要y'n+1来计算yn+1，因此必须使用另一种方法来计算yn+1的第一个估计值，然后计算y'n+1，然后使用以下公式计算yn+1的最终估计值。根据要使用的前几步数k，不同的公式可用于最终估计：

  • 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
  • ...

一个k步的Adams-Moulton方法的阶数为k+1。

在最后一个重置事件和积分结束之间必须有足够的时间供starter integrator执行多个步骤，否则在积分过程中可能会抛出异常。用户可以调整积分的结束日期或起始积分器的步长，以确保在积分结束之前可以完成足够数量的步骤。

实现细节

我们将第n步的缩放导数si(n)定义为：\[ \left\{\begin{align} s_1(n) &= h y'_n \text{ for first derivative}\\ s_2(n) &= \frac{h^2}{2} y_n'' \text{ for second derivative}\\ s_3(n) &= \frac{h^3}{6} y_n''' \text{ for third derivative}\\ &\cdots\\ s_k(n) &= \frac{h^k}{k!} y_n^{(k)} \text{ for } k^\mathrm{th} \text{ derivative} \end{align}\right. \]

上述定义使用了经典表示，其中包含几个先前的一阶导数。让我们定义 \[ q_n = [ s_1(n-1) s_1(n-2) \ldots s_1(n-(k-1)) ]^T \]（为清晰起见，我们在符号中省略了k索引）。使用这些定义，Adams-Moulton方法可以写成：

  • 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
  • ...

我们的实现不是使用仅包含一阶导数的经典表示（yn，s1(n+1)和qn+1），而是使用在同一步骤中获取的更高阶缩放导数的Nordsieck向量（yn，s1(n)和rn），其中rn定义为：\[ r_n = [ s_2(n), s_3(n) \ldots s_k(n) ]^T \]（在这里我们再次省略了符号中的k索引）

泰勒级数公式表明，对于任何索引偏移i，s1(n-i)可以从s1(n)，s2(n) ... sk(n)计算出来，该公式对于k次多项式是精确的。\[ s_1(n-i) = s_1(n) + \sum_{j\gt 0} (j+1) (-i)^j s_{j+1}(n) \] 可以使用几个i值来计算经典表示和Nordsieck向量之间的转换。由上述泰勒级数公式导致的rn和qn之间的转换是：\[ q_n = s_1(n) u + P r_n \] 其中u是[ 1 1 ... 1 ]T向量，P是(k-1)×(k-1)矩阵，由带有\((j+1) (-i)^j\)项的行数构建，其中i是从1开始的行号，j是从1开始的列号：\[ P=\begin{bmatrix} -2 & 3 & -4 & 5 & \ldots \\ -4 & 12 & -32 & 80 & \ldots \\ -6 & 27 & -108 & 405 & \ldots \\ -8 & 48 & -256 & 1280 & \ldots \\ & & \ldots\\ \end{bmatrix} \]

使用Nordsieck向量有几个优点：

  • 它极大地简化了步骤插值，因为插值器主要应用泰勒级数公式，
  • 当触发截断步骤的离散事件时，它简化了步骤更改，
  • 它允许扩展方法以支持自适应步长。

第n+1步的预测Nordsieck向量是从第n步的Nordsieck向量计算得到的：

  • 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
其中A是行移位矩阵（左下部分是单位矩阵）： 
        [ 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 ]
从这个预测向量中，校正向量计算如下：
  • 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

其中大写的Yn+1、S1(n+1)和Rn+1表示预测状态，而小写的yn+1、sn+1和rn+1表示校正状态。

P-1u向量和P-1 A P矩阵不依赖于状态，它们仅依赖于k，因此一次性预先计算。

  • 构造器详细资料

    • AdamsMoultonFieldIntegrator

      public AdamsMoultonFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double scalAbsoluteTolerance, double scalRelativeTolerance) throws MathIllegalArgumentException
      使用给定的阶数和误差控制参数构建Adams-Moulton积分器。
      参数:
      field - 时间和状态向量元素所属的字段
      nSteps - 方法的步数，不包括正在计算的步骤
      minStep - 最小步长（符号无关，无论积分方向是向前还是向后，最后一步可以小于此值）
      maxStep - 最大步长（符号无关，无论积分方向是向前还是向后，最后一步可以小于此值）
      scalAbsoluteTolerance - 允许的绝对误差
      scalRelativeTolerance - 允许的相对误差
      抛出:
      MathIllegalArgumentException - 如果阶数小于等于1

    • AdamsMoultonFieldIntegrator

      public AdamsMoultonFieldIntegrator(Field<T> field, int nSteps, double minStep, double maxStep, double[] vecAbsoluteTolerance, double[] vecRelativeTolerance) throws IllegalArgumentException
      使用给定的阶数和误差控制参数构建Adams-Moulton积分器。
      参数:
      field - 时间和状态向量元素所属的字段
      nSteps - 方法的步数，不包括正在计算的步骤
      minStep - 最小步长（符号无关，无论积分方向是向前还是

  • 方法详细资料

    • errorEstimation

      protected double errorEstimation(T[] previousState, T predictedTime, T[] predictedState, T[] predictedScaled, FieldMatrix<T> predictedNordsieck)
      Estimate error.
      指定者:
      errorEstimation 在类中 AdamsFieldIntegrator<T extends CalculusFieldElement<T>>
      参数:
      previousState - 步骤开始时的状态向量
      predictedTime - 步骤结束时的时间
      predictedState - 步骤结束时的预测状态向量
      predictedScaled - 步骤结束时的缩放导数的预测值
      predictedNordsieck - 步骤结束时的Nordsieck向量的预测值
      返回:
      估计的归一化局部离散化误差

    • finalizeStep

      protected org.hipparchus.ode.nonstiff.AdamsFieldStateInterpolator<T> finalizeStep(T stepSize, T[] predictedY, T[] predictedScaled, Array2DRowFieldMatrix<T> predictedNordsieck, boolean isForward, FieldODEStateAndDerivative<T> globalPreviousState, FieldODEStateAndDerivative<T> globalCurrentState, FieldEquationsMapper<T> equationsMapper)
      完成步骤。
      指定者:
      finalizeStep 在类中 AdamsFieldIntegrator<T extends CalculusFieldElement<T>>
      参数:
      stepSize - 缩放和Nordsieck数组中使用的步长
      predictedY - 步骤结束时的预测状态
      predictedScaled - 预测的第一个缩放导数
      predictedNordsieck - 预测的Nordsieck向量
      isForward - 积分方向指示器
      globalPreviousState - 全局步骤的起始点
      globalCurrentState - 全局步骤的结束点
      equationsMapper - ODE方程主要和次要分量的映射器
      返回:
      步骤插值器