程序包 org.hipparchus.ode.nonstiff

类 AdamsBashforthFieldIntegrator<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.AdamsBashforthFieldIntegrator<T>
类型参数:
T - 字段元素的类型
所有已实现的接口:
FieldODEIntegrator<T>
public class AdamsBashforthFieldIntegrator<T extends CalculusFieldElement<T>> extends AdamsFieldIntegrator<T>
该类实现了用于常微分方程的显式Adams-Bashforth积分器。

Adams-Bashforth方法（实际上只是Adams的方法）是显式的多步ODE求解器。这个实现是经典方法的变体：它使用自适应步长来实现误差控制，而经典实现是固定步长的。在步骤n+1处的状态向量的值是步骤n处的值和步骤n、n-1、n-2等处的导数的简单组合。根据想要用于计算下一个值的前k个步骤的数量k，不同的公式可用：

  • k = 1: yn+1 = yn + h y'n
  • k = 2: yn+1 = yn + h (3y'n-y'n-1)/2
  • k = 3: yn+1 = yn + h (23y'n-16y'n-1+5y'n-2)/12
  • k = 4: yn+1 = yn + h (55y'n-59y'n-1+37y'n-2-9y'n-3)/24
  • ...

一个k步的Adams-Bashforth方法的阶数为k。

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

实现细节

我们将步骤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-Bashforth方法可以写成：\[ \left\{\begin{align} k = 1: & y_{n+1} = y_n + s_1(n) \\ k = 2: & y_{n+1} = y_n + \frac{3}{2} s_1(n) + [ \frac{-1}{2} ] q_n \\ k = 3: & y_{n+1} = y_n + \frac{23}{12} s_1(n) + [ \frac{-16}{12} \frac{5}{12} ] q_n \\ k = 4: & y_{n+1} = y_n + \frac{55}{24} s_1(n) + [ \frac{-59}{24} \frac{37}{24} \frac{-9}{24} ] q_n \\ & \cdots \end{align}\right. \]

我们的实现不是使用仅包含一阶导数的经典表示法（yn、s1(n)和qn），而是使用了在同一步骤中取得的更高次数的缩放导数的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\)项的行数为1开始的i和列数为1开始的j构建：\[ 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向量的计算方法如下：

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

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

  • 构造器详细资料

    • AdamsBashforthFieldIntegrator

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

    • AdamsBashforthFieldIntegrator

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

  • 方法详细资料

    • errorEstimation

      protected double errorEstimation(T[] previousState, T predictedTime, T[] predictedState, T[] predictedScaled, FieldMatrix<T> predictedNordsieck)
      估计误差。
      指定者:
      errorEstimation 在类中 AdamsFieldIntegrator<T extends

    • 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)
      Finalize the step.
      指定者:
      finalizeStep 在类中 AdamsFieldIntegrator<T extends CalculusFieldElement<T>>
      参数:
      stepSize - 在缩放和Nordsieck数组中使用的步长
      predictedY - 预测步骤结束时的状态
      predictedScaled - 预测的第一个缩放导数
      predictedNordsieck - 预测的Nordsieck向量
      isForward - 积分方向指示器
      globalPreviousState - 全局步骤的起点
      globalCurrentState - 全局步骤的终点
      equationsMapper - ODE方程主要和次要分量的映射器
      返回:
      步骤插值器