程序包 org.hipparchus.analysis.differentiation

类 DSCompiler

java.lang.Object
org.hipparchus.analysis.differentiation.DSCompiler
public class DSCompiler extends Object
Class holding "compiled" computation rules for derivative structures.

该类保存导数结构的“编译”计算规则。

该类实现了Dan Kalman在其论文中描述的计算规则《Doubly Recursive Multivariate Automatic Differentiation》，Mathematics Magazine，vol. 75，no. 3，June 2002。但是，为了避免性能瓶颈，递归规则在展开形式中“编译”一次。该类执行此递归展开并将计算规则存储为具有预先计算的间接数组的简单循环。

该类将所有导数计算映射到保存值和偏导数的单维数组中。该类不保存这些数组，这仍由调用者负责。对于每种自由参数数量和导数阶数的组合，只需要一个编译器，并且此编译器将用于对提供给它的所有数组执行计算，这些数组可以表示与所有偏导数一起保留的数百或数千个不同参数。

编译器操作的数组仅包含偏导数以及第0阶导数，即值。偏导数按照特定于编译器的顺序存储，可以使用方法getPartialDerivativeIndex和getPartialDerivativeOrders检索。保证值存储为第一个元素（即当使用0作为所有导数阶数调用时，getPartialDerivativeIndex方法返回0，getPartialDerivativeOrders在使用0作为索引时返回填充有0的数组）。

请注意，随着参数数量和导数阶数的变化，顺序也会改变。例如，给定2个参数x和y，当导数阶数设置为1时，df/dy存储在索引2处（在这种情况下，数组有三个元素：f，df/dx和df/dy）。如果导数阶数设置为2，则df/dy将存储在索引3处（在这种情况下，数组有六个元素：f，df/dx，d²f/dxdx，df/dy，d²f/dxdy和d²f/dydy）。

有了这种结构，用户可以执行一些简单的操作，如添加、减去或乘以常数，并通过自身对元素取反，知道他们是要改变其数组还是创建新数组。这些简单操作不是由编译器提供的。编译器仅提供几个数组之间的更复杂操作。

该类主要用作标量变量DerivativeStructure的引擎。它也可以直接用于在数组中保存多个变量以用于更复杂的数据结构。例如，用户可以将依赖于三个自由参数x、y和z的n个变量的向量存储在一个数组中，如下所示：

   // 参数0是x，参数1是y，参数2是z
   int parameters = 3;
   DSCompiler compiler = DSCompiler.getCompiler(parameters, order);
   int size = compiler.getSize();

   // 将所有元素打包到单个数组中
   double[] array = new double[n * size];
   for (int i = 0; i < n; ++i) {

     // 我们知道值保证是第一个元素
     array[i * size] = v[i];

     // 我们不知道第一阶导数存储在哪里，因此我们询问编译器
     array[i * size + compiler.getPartialDerivativeIndex(1, 0, 0) = dvOnDx[i][0];
     array[i * size + compiler.getPartialDerivativeIndex(0, 1, 0) = dvOnDy[i][0];
     array[i * size + compiler.getPartialDerivativeIndex(0, 0, 1) = dvOnDz[i][0];

     // 我们将所有高阶导数设置为0

   }

然后，在另一个函数中，用户可以对存储在单个数组中的所有元素执行一些操作，例如所有变量的简单乘积：

   // 计算所有元素的乘积
   double[] product = new double[size];
   prod[0] = 1.0;
   for (int i = 0; i < n; ++i) {
     double[] tmp = product.clone();
     compiler.multiply(tmp, 0, array, i * size, product, 0);
   }

   // 值
   double p = product[0];

   // 第一阶导数
   double dPdX = product[compiler.getPartialDerivativeIndex(1, 0, 0)];
   double dPdY = product[compiler.getPartialDerivativeIndex(0, 1, 0)];
   double dPdZ = product[compiler.getPartialDerivativeIndex(0, 0, 1)];

   // 交叉导数（假设阶数至少为2）
   double dPdXdX = product[compiler.getPartialDerivativeIndex(2, 0, 0)];
   double dPdXdY = product[compiler.getPartialDerivativeIndex(1, 1, 0)];
   double dPdXdZ = product[compiler.getPartialDerivativeIndex(1, 0, 1)];
   double dPdYdY = product[compiler.getPartialDerivativeIndex(0, 2, 0)];
   double dPdYdZ = product[compiler.getPartialDerivativeIndex(0, 1, 1)];
   double dPdZdZ = product[compiler.getPartialDerivativeIndex(0, 0, 2)];
另请参阅:

  • 方法概要

    修饰符和类型
    方法
    说明
    void
    acos(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反余弦。
    <T extends CalculusFieldElement<T>>
    void
    acos(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反余弦。
    void
    acosh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反双曲余弦。
    <T extends CalculusFieldElement<T>>
    void
    acosh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反双曲余弦。
    void
    add(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
    执行两个导数结构的加法。
    <T extends CalculusFieldElement<T>>
    void
    add(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
    执行两个导数结构的加法。
    void
    asin(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反正弦。
    <T extends CalculusFieldElement<T>>
    void
    asin(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反正弦。
    void
    asinh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反双曲正弦。
    <T extends CalculusFieldElement<T>>
    void
    asinh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反双曲正弦。
    void
    atan(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反正切。
    <T extends CalculusFieldElement<T>>
    void
    atan(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反正切。
    void
    atan2(double[] y, int yOffset, double[] x, int xOffset, double[] result, int resultOffset)
    计算导数结构的双参数反正切。
    <T extends CalculusFieldElement<T>>
    void
    atan2(T[] y, int yOffset, T[] x, int xOffset, T[] result, int resultOffset)
    计算导数结构的双参数反正切。
    void
    atanh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的反双曲正切。
    <T extends CalculusFieldElement<T>>
    void
    atanh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的反双曲正切。
    void
    checkCompatibility(DSCompiler compiler)
    检查规则集的兼容性。
    void
    compose(double[] operand, int operandOffset, double[] f, double[] result, int resultOffset)
    通过函数计算导数结构的组合。
    <T extends CalculusFieldElement<T>>
    void
    compose(T[] operand, int operandOffset, double[] f, T[] result, int resultOffset)
    通过函数计算导数结构的组合。
    <T extends CalculusFieldElement<T>>
    void
    compose(T[] operand, int operandOffset, T[] f, T[] result, int resultOffset)
    通过函数计算导数结构的组合。
    void
    cos(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的余弦。
    <T extends CalculusFieldElement<T>>
    void
    cos(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的余弦。
    void
    cosh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的双曲余弦。
    <T extends CalculusFieldElement<T>>
    void
    cosh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的双曲余弦。
    void
    divide(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
    执行两个导数结构的除法。
    <T extends CalculusFieldElement<T>>
    void
    divide(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
    执行两个导数结构的除法。
    void
    exp(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的指数。
    <T extends CalculusFieldElement<T>>
    void
    exp(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的指数。
    void
    expm1(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的exp(x) - 1。
    <T extends CalculusFieldElement<T>>
    void
    expm1(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的exp(x) - 1。
    static DSCompiler
    getCompiler(int parameters, int order)
    获取自由参数数量和阶数的编译器。
    int
    getFreeParameters()
    获取自由参数数量。
    int
    getOrder()
    获取导数阶数。
    int
    getPartialDerivativeIndex(int... orders)
    获取数组中偏导数的索引。
    int[]
    getPartialDerivativeOrders(int index)
    获取数组中特定索引的导数阶数。
    int
    getPartialDerivativeOrdersSum(int index)
    获取数组中特定索引的导数阶数之和。
    int
    getSize()
    获取保存偏导数数据所需的数组大小。
    void
    linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double[] result, int resultOffset)
    计算线性组合。
    void
    linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double a3, double[] c3, int offset3, double[] result, int resultOffset)
    计算线性组合。
    void
    linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double a3, double[] c3, int offset3, double a4, double[] c4, int offset4, double[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, double a3, T[] c3, int offset3, double a4, T[] c4, int offset4, T[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, double a3, T[] c3, int offset3, T[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, T[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T a3, T[] c3, int offset3, T[] result, int resultOffset)
    计算线性组合。
    <T extends CalculusFieldElement<T>>
    void
    linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T a3, T[] c3, int offset3, T a4, T[] c4, int offset4, T[] result, int resultOffset)
    计算线性组合。
    void
    log(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的自然对数。
    <T extends CalculusFieldElement<T>>
    void
    log(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的自然对数。
    void
    log10(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的以10为底的对数。
    <T extends CalculusFieldElement<T>>
    void
    log10(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的以10为底的对数。
    void
    log1p(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的移位对数。
    <T extends CalculusFieldElement<T>>
    void
    log1p(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的移位对数。
    void
    multiply(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
    执行两个导数结构的乘法。
    <T extends CalculusFieldElement<T>>
    void
    multiply(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
    执行两个导数结构的乘法。
    void
    pow(double[] x, int xOffset, double[] y, int yOffset, double[] result, int resultOffset)
    计算导数结构的幂。
    void
    pow(double[] operand, int operandOffset, double p, double[] result, int resultOffset)
    计算导数结构的幂。
    void
    pow(double[] operand, int operandOffset, int n, double[] result, int resultOffset)
    计算导数结构的整数幂。
    void
    pow(double a, double[] operand, int operandOffset, double[] result, int resultOffset)
    计算双精度数的幂到导数结构。
    <T extends CalculusFieldElement<T>>
    void
    pow(double a, T[] operand, int operandOffset, T[] result, int resultOffset)
    计算双精度数的幂到导数结构。
    <T extends CalculusFieldElement<T>>
    void
    pow(T[] operand, int operandOffset, double p, T[] result, int resultOffset)
    计算导数结构的幂。
    <T extends CalculusFieldElement<T>>
    void
    pow(T[] operand, int operandOffset, int n, T[] result, int resultOffset)
    计算导数结构的整数幂。
    <T extends CalculusFieldElement<T>>
    void
    pow(T[] x, int xOffset, T[] y, int yOffset, T[] result, int resultOffset)
    计算导数结构的幂。
    void
    rebase(double[] ds, int dsOffset, DSCompiler baseCompiler, double[] p, double[] result, int resultOffset)
    相对于低级参数函数重新定位导数结构。
    <T extends CalculusFieldElement<T>>
    void
    rebase(T[] ds, int dsOffset, DSCompiler baseCompiler, T[] p, T[] result, int resultOffset)
    相对于低级参数函数重新定位导数结构。
    void
    reciprocal(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的倒数。
    <T extends CalculusFieldElement<T>>
    void
    reciprocal(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的倒数。
    void
    remainder(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
    执行两个导数结构的余数。
    <T extends CalculusFieldElement<T>>
    void
    remainder(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
    执行两个导数结构的余数。
    void
    rootN(double[] operand, int operandOffset, int n, double[] result, int resultOffset)
    计算导数结构的nth次根。
    <T extends CalculusFieldElement<T>>
    void
    rootN(T[] operand, int operandOffset, int n, T[] result, int resultOffset)
    计算导数结构的nth次根。
    void
    sin(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的正弦。
    <T extends CalculusFieldElement<T>>
    void
    sin(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的正弦。
    void
    sinCos(double[] operand, int operandOffset, double[] sin, int sinOffset, double[] cos, int cosOffset)
    计算导数结构的正弦和余弦的组合。
    <T extends CalculusFieldElement<T>>
    void
    sinCos(T[] operand, int operandOffset, T[] sin, int sinOffset, T[] cos, int cosOffset)
    计算导数结构的正弦和余弦的组合。
    void
    sinh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的双曲正弦。
    <T extends CalculusFieldElement<T>>
    void
    sinh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的双曲正弦。
    void
    sinhCosh(double[] operand, int operandOffset, double[] sinh, int sinhOffset, double[] cosh, int coshOffset)
    计算导数结构的双曲正弦和余弦的组合。
    <T extends CalculusFieldElement<T>>
    void
    sinhCosh(T[] operand, int operandOffset, T[] sinh, int sinhOffset, T[] cosh, int coshOffset)
    计算导数结构的双曲正弦和余弦的组合。
    void
    sqrt(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的平方根。
    <T extends CalculusFieldElement<T>>
    void
    sqrt(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的平方根。
    void
    subtract(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
    执行两个导数结构的减法。
    <T extends CalculusFieldElement<T>>
    void
    subtract(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
    执行两个导数结构的减法。
    void
    tan(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的正切。
    <T extends CalculusFieldElement<T>>
    void
    tan(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的正切。
    void
    tanh(double[] operand, int operandOffset, double[] result, int resultOffset)
    计算导数结构的双曲正切。
    <T extends CalculusFieldElement<T>>
    void
    tanh(T[] operand, int operandOffset, T[] result, int resultOffset)
    计算导数结构的双曲正切。
    double
    taylor(double[] ds, int dsOffset, double... delta)
    计算导数结构的泰勒展开。
    <T extends CalculusFieldElement<T>>
    T
    taylor(T[] ds, int dsOffset, double... delta)
    计算导数结构的泰勒展开。
    final <T extends CalculusFieldElement<T>>
    T
    taylor(T[] ds, int dsOffset, T... delta)
    计算导数结构的泰勒展开。

    从类继承的方法 java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • 方法详细资料

    • getCompiler

      public static DSCompiler getCompiler(int parameters, int order) throws MathIllegalArgumentException
      获取自由参数数量和阶数的编译器。
      参数:
      parameters - 自由参数数量
      order - 导数阶数
      返回:
      缓存的规则集
      抛出:
      MathIllegalArgumentException - 如果阶数过大

    • getPartialDerivativeIndex

      public int getPartialDerivativeIndex(int... orders) throws MathIllegalArgumentException
      获取数组中部分导数的索引。

      如果所有阶数都设置为0，则返回第0阶导数，即函数的值。

      导数的索引在0和getSize() - 1之间。对于给定的编译器，它们的特定顺序是固定的，但不是公开指定的。然而，有一些简单的情况具有保证的索引：

      • 第0阶导数的索引始终为0
      • 如果只有1个自由参数，则导数按增加的导数顺序排序（即f在索引0处，df/dp在索引1处，d2f/dp2在索引2处... dkf/dpk在索引k处），
      • 如果导数阶数为1，则导数按增加的自由参数顺序排序（即f在索引0处，df/dx1在索引1处，df/dx2在索引2处... df/dxk在索引k处），
      • 所有其他情况未公开指定

      此方法是方法getPartialDerivativeOrders(int)的逆方法

      参数:
      orders - 相对于每个参数的导数阶数
      返回:
      部分导数的索引
      抛出:
      MathIllegalArgumentException - 如果参数数量与实例不匹配
      MathIllegalArgumentException - 如果导数阶数之和大于实例限制
      另请参阅:

    • getPartialDerivativeOrders

      public int[] getPartialDerivativeOrders(int index)
      获取数组中特定索引的导数阶数。

      此方法是getPartialDerivativeIndex(int...)的逆方法。

      参数:
      index - 部分导数的索引
      返回:
      相对于每个参数的导数阶数
      另请参阅:

    • getPartialDerivativeOrdersSum

      public int getPartialDerivativeOrdersSum(int index)
      获取数组中特定索引的导数阶数之和。

      此方法返回由getPartialDerivativeIndex(int...)返回的元素之和，使用预先计算的值

      参数:
      index - 部分导数的索引
      返回:
      相对于每个参数的导数阶数之和
      从以下版本开始:
      2.2
      另请参阅:

    • getFreeParameters

      public int getFreeParameters()
      获取自由参数数量。
      返回:
      自由参数数量

    • getOrder

      public int getOrder()
      获取导数阶数。
      返回:
      导数阶数

    • getSize

      public int getSize()
      获取用于保存部分导数数据所需的数组大小。

      此数字包括单个0阶导数元素，保证存储在数组的第一个元素中。

      返回:
      用于保存部分导数数据所需的数组大小

    • linearCombination

      public void linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）组件
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）组件
      offset2 - 第二个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）组件
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）组件
      offset2 - 第二个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）组件
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）组件
      offset2 - 第二个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public void linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double a3, double[] c3, int offset3, double[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）组件
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）组件
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）组件
      offset3 - 第三个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T a3, T[] c3, int offset3, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）组件
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）组件
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）组件
      offset3 - 第三个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, double a3, T[] c3, int offset3, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将是a1 * ds1 + a2 * ds2 + a3
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）分量
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）分量
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）分量
      offset3 - 第三个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public void linearCombination(double a1, double[] c1, int offset1, double a2, double[] c2, int offset2, double a3, double[] c3, int offset3, double a4, double[] c4, int offset4, double[] result, int resultOffset)
      计算线性组合。构建的导数结构将为 a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）分量
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）分量
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）分量
      offset3 - 第三个操作数在其数组中的偏移量
      a4 - 第四个比例因子
      c4 - 第四个基础（未缩放）分量
      offset4 - 第四个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(T a1, T[] c1, int offset1, T a2, T[] c2, int offset2, T a3, T[] c3, int offset3, T a4, T[] c4, int offset4, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将为 a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）分量
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）分量
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）分量
      offset3 - 第三个操作数在其数组中的偏移量
      a4 - 第四个比例因子
      c4 - 第四个基础（未缩放）分量
      offset4 - 第四个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • linearCombination

      public <T extends CalculusFieldElement<T>> void linearCombination(double a1, T[] c1, int offset1, double a2, T[] c2, int offset2, double a3, T[] c3, int offset3, double a4, T[] c4, int offset4, T[] result, int resultOffset)
      计算线性组合。构建的导数结构将为 a1 * ds1 + a2 * ds2 + a3 * ds3 + a4 * ds4
      类型参数:
      T - 函数参数和值的类型
      参数:
      a1 - 第一个比例因子
      c1 - 第一个基础（未缩放）分量
      offset1 - 第一个操作数在其数组中的偏移量
      a2 - 第二个比例因子
      c2 - 第二个基础（未缩放）分量
      offset2 - 第二个操作数在其数组中的偏移量
      a3 - 第三个比例因子
      c3 - 第三个基础（未缩放）分量
      offset3 - 第三个操作数在其数组中的偏移量
      a4 - 第四个比例因子
      c4 - 第四个基础（未缩放）分量
      offset4 - 第四个操作数在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • add

      public void add(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
      执行两个导数结构的加法。
      参数:
      lhs - 包含加法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 加法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • add

      public <T extends CalculusFieldElement<T>> void add(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
      执行两个导数结构的加法。
      类型参数:
      T - 函数参数和值的类型
      参数:
      lhs - 包含加法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 加法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • subtract

      public void subtract(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
      执行两个导数结构的减法。
      参数:
      lhs - 包含减法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 减法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • subtract

      public <T extends CalculusFieldElement<T>> void subtract(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
      执行两个导数结构的减法。
      类型参数:
      T - 函数参数和值的类型
      参数:
      lhs - 包含减法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 减法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • multiply

      public void multiply(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
      执行两个导数结构的乘法。
      参数:
      lhs - 包含乘法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 乘法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（对于乘法，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • multiply

      public <T extends CalculusFieldElement<T>> void multiply(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
      执行两个导数结构的乘法。
      类型参数:
      T - 函数参数和值的类型
      参数:
      lhs - 包含乘法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 乘法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（对于乘法，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • divide

      public void divide(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
      执行两个导数结构的除法。基于乘法运算符。
      参数:
      lhs - 包含除法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 除法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（对于除法，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • divide

      public <T extends CalculusFieldElement<T>> void divide(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
      执行两个导数结构的除法。基于乘法运算符。
      类型参数:
      T - 函数参数和值的类型
      参数:
      lhs - 包含除法左手边的数组
      lhsOffset - 左手边在其数组中的偏移量
      rhs - 除法右手边的数组
      rhsOffset - 右手边在其数组中的偏移量
      result - 必须存储结果的数组（对于除法，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • reciprocal

      public void reciprocal(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的倒数。基于乘法运算符。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组
      resultOffset - 结果在其数组中的偏移量

    • reciprocal

      public <T extends CalculusFieldElement<T>> void reciprocal(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的倒数。基于乘法运算符。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组
      resultOffset - 结果在其数组中的

    • remainder

      public void remainder(double[] lhs, int lhsOffset, double[] rhs, int rhsOffset, double[] result, int resultOffset)
      Perform remainder of two derivative structures.
      参数:
      lhs - array holding left hand side of remainder
      lhsOffset - offset of the left hand side in its array
      rhs - array right hand side of remainder
      rhsOffset - offset of the right hand side in its array
      result - array where result must be stored (it may be one of the input arrays)
      resultOffset - offset of the result in its array

    • remainder

      public <T extends CalculusFieldElement<T>> void remainder(T[] lhs, int lhsOffset, T[] rhs, int rhsOffset, T[] result, int resultOffset)
      Perform remainder of two derivative structures.
      类型参数:
      T - 函数参数和值的类型
      参数:
      lhs - 存储余数左侧的数组
      lhsOffset - 左侧数组中左侧的偏移量
      rhs - 存储余数右侧的数组
      rhsOffset - 右侧数组中右侧的偏移量
      result - 必须存储结果的数组（可以是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public void pow(double a, double[] operand, int operandOffset, double[] result, int resultOffset)
      计算将双精度数提升到导数结构的幂。
      参数:
      a - 要求幂的数字
      operand - 存储幂的数组
      operandOffset - 幂在其数组中的偏移量
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public <T extends CalculusFieldElement<T>> void pow(double a, T[] operand, int operandOffset, T[] result, int resultOffset)
      计算将双精度数提升到导数结构的幂。
      类型参数:
      T - 函数参数和值的类型
      参数:
      a - 要求幂的数字
      operand - 存储幂的数组
      operandOffset - 幂在其数组中的偏移量
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public void pow(double[] operand, int operandOffset, double p, double[] result, int resultOffset)
      计算导数结构的幂。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      p - 要应用的幂
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public <T extends CalculusFieldElement<T>> void pow(T[] operand, int operandOffset, double p, T[] result, int resultOffset)
      计算导数结构的幂。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      p - 要应用的幂
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public void pow(double[] operand, int operandOffset, int n, double[] result, int resultOffset)
      计算导数结构的整数幂。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      n - 要应用的幂
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public <T extends CalculusFieldElement<T>> void pow(T[] operand, int operandOffset, int n, T[] result, int resultOffset)
      计算导数结构的整数幂。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      n - 要应用的幂
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public void pow(double[] x, int xOffset, double[] y, int yOffset, double[] result, int resultOffset)
      计算导数结构的幂。
      参数:
      x - 存储底数的数组
      xOffset - 底数在其数组中的偏移量
      y - 存储指数的数组
      yOffset - 指数在其数组中的偏移量
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • pow

      public <T extends CalculusFieldElement<T>> void pow(T[] x, int xOffset, T[] y, int yOffset, T[] result, int resultOffset)
      计算导数结构的幂。
      类型参数:
      T - 函数参数和值的类型
      参数:
      x - 存储底数的数组
      xOffset - 底数在其数组中的偏移量
      y - 存储指数的数组
      yOffset - 指数在其数组中的偏移量
      result - 必须存储结果的数组（对于幂，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • sqrt

      public void sqrt(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的平方根。基于乘法运算符。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于平方根，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • sqrt

      public <T extends CalculusFieldElement<T>> void sqrt(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的平方根。基于乘法运算符。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于平方根，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • rootN

      public void rootN(double[] operand, int operandOffset, int n, double[] result, int resultOffset)
      计算导数结构的nth次根。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      n - 根的阶数
      result - 必须存储结果的数组（对于nth根，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • rootN

      public <T extends CalculusFieldElement<T>> void rootN(T[] operand, int operandOffset, int n, T[] result, int resultOffset)
      计算导数结构的nth次根。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      n - 根的阶数
      result - 必须存储结果的数组（对于nth根，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • exp

      public void exp(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的指数。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于指数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • exp

      public <T extends CalculusFieldElement<T>> void exp(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的指数。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于指数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • expm1

      public void expm1(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的exp(x) - 1。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于指数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • expm1

      public <T extends CalculusFieldElement<T>> void expm1(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的exp(x) - 1。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于指数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • log

      public void log(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的自然对数。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于对数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • log

      public <T extends CalculusFieldElement<T>> void log(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的自然对数。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于对数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • log1p

      public void log1p(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的移位对数。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于移位对数，结果数组不能是输入数组之一）
      resultOffset - 结果在其数组中的偏移量

    • log1p

      public <T extends CalculusFieldElement<T>> void log1p(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于移位对数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • log10

      public void log10(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的以10为底的对数。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于以10为底的对数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • log10

      public <T extends CalculusFieldElement<T>> void log10(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的以10为底的对数。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于以10为底的对数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • cos

      public void cos(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的余弦值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于余弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • cos

      public <T extends CalculusFieldElement<T>> void cos(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的余弦值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于余弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sin

      public void sin(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的正弦值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于正弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sin

      public <T extends CalculusFieldElement<T>> void sin(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的正弦值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于正弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sinCos

      public void sinCos(double[] operand, int operandOffset, double[] sin, int sinOffset, double[] cos, int cosOffset)
      计算导数结构的正弦和余弦值的组合。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      sin - 必须存储正弦值的数组（对于正弦值，结果数组不能是输入数组）
      sinOffset - 结果在其数组中的偏移量
      cos - 必须存储余弦值的数组（对于余弦值，结果数组不能是输入数组）
      cosOffset - 结果在其数组中的偏移量
      从以下版本开始:
      1.4

    • sinCos

      public <T extends CalculusFieldElement<T>> void sinCos(T[] operand, int operandOffset, T[] sin, int sinOffset, T[] cos, int cosOffset)
      计算导数结构的正弦和余弦值的组合。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      sin - 必须存储正弦值的数组（对于正弦值，结果数组不能是输入数组）
      sinOffset - 结果在其数组中的偏移量
      cos - 必须存储余弦值的数组（对于余弦值，结果数组不能是输入数组）
      cosOffset - 结果在其数组中的偏移量
      从以下版本开始:
      1.4

    • tan

      public void tan(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的正切值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • tan

      public <T extends CalculusFieldElement<T>> void tan(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的正切值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • acos

      public void acos(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反余弦值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反余弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • acos

      public <T extends CalculusFieldElement<T>> void acos(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反余弦值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反余弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • asin

      public void asin(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反正弦值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反正弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • asin

      public <T extends CalculusFieldElement<T>> void asin(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反正弦值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反正弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atan

      public void atan(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反正切值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atan

      public <T extends CalculusFieldElement<T>> void atan(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反正切值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atan2

      public void atan2(double[] y, int yOffset, double[] x, int xOffset, double[] result, int resultOffset)
      计算导数结构的两参数反正切值。
      参数:
      y - 存储第一个操作数的数组
      yOffset - 第一个操作数在其数组中的偏移量
      x - 存储第二个操作数的数组
      xOffset - 第二个操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于两参数反正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atan2

      public <T extends CalculusFieldElement<T>> void atan2(T[] y, int yOffset, T[] x, int xOffset, T[] result, int resultOffset)
      计算导数结构的两参数反正切值。
      类型参数:
      T - 函数参数和值的类型
      参数:
      y - 存储第一个操作数的数组
      yOffset - 第一个操作数在其数组中的偏移量
      x - 存储第二个操作数的数组
      xOffset - 第二个操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于两参数反正切值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • cosh

      public void cosh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的双曲余弦值。
      参数:
      operand - 存储操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲余弦值，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • cosh

      public <T extends CalculusFieldElement<T>> void cosh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的双曲余弦
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲余弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sinh

      public void sinh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的双曲正弦。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲正弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sinh

      public <T extends CalculusFieldElement<T>> void sinh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的双曲正弦。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲正弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • sinhCosh

      public void sinhCosh(double[] operand, int operandOffset, double[] sinh, int sinhOffset, double[] cosh, int coshOffset)
      计算导数结构的双曲正弦和余弦的组合。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      sinh - 必须存储双曲正弦的数组（对于正弦函数，结果数组不能是输入数组）
      sinhOffset - 结果在其数组中的偏移量
      cosh - 必须存储双曲余弦的数组（对于余弦函数，结果数组不能是输入数组）
      coshOffset - 结果在其数组中的偏移量
      从以下版本开始:
      2.0

    • sinhCosh

      public <T extends CalculusFieldElement<T>> void sinhCosh(T[] operand, int operandOffset, T[] sinh, int sinhOffset, T[] cosh, int coshOffset)
      计算导数结构的双曲正弦和余弦的组合。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      sinh - 必须存储双曲正弦的数组（对于正弦函数，结果数组不能是输入数组）
      sinhOffset - 结果在其数组中的偏移量
      cosh - 必须存储双曲余弦的数组（对于余弦函数，结果数组不能是输入数组）
      coshOffset - 结果在其数组中的偏移量
      从以下版本开始:
      1.4

    • tanh

      public void tanh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的双曲正切。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲正切函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • tanh

      public <T extends CalculusFieldElement<T>> void tanh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的双曲正切。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于双曲正切函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • acosh

      public void acosh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反双曲余弦。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲余弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • acosh

      public <T extends CalculusFieldElement<T>> void acosh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反双曲余弦。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲余弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • asinh

      public void asinh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反双曲正弦。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲正弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • asinh

      public <T extends CalculusFieldElement<T>> void asinh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反双曲正弦。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲正弦函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atanh

      public void atanh(double[] operand, int operandOffset, double[] result, int resultOffset)
      计算导数结构的反双曲正切。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲正切函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • atanh

      public <T extends CalculusFieldElement<T>> void atanh(T[] operand, int operandOffset, T[] result, int resultOffset)
      计算导数结构的反双曲正切。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      result - 必须存储结果的数组（对于反双曲正切函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • compose

      public void compose(double[] operand, int operandOffset, double[] f, double[] result, int resultOffset)
      计算导数结构的函数组合。
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      f - 函数在当前点（即operand[operandOffset]处）的值和导数的数组
      result - 必须存储结果的数组（对于组合函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • compose

      public <T extends CalculusFieldElement<T>> void compose(T[] operand, int operandOffset, T[] f, T[] result, int resultOffset)
      计算导数结构的函数组合。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      f - 函数在当前点（即operand[operandOffset]处）的值和导数的数组
      result - 必须存储结果的数组（对于组合函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • compose

      public <T extends CalculusFieldElement<T>> void compose(T[] operand, int operandOffset, double[] f, T[] result, int resultOffset)
      计算导数结构的函数组合。
      类型参数:
      T - 函数参数和值的类型
      参数:
      operand - 包含操作数的数组
      operandOffset - 操作数在其数组中的偏移量
      f - 函数在当前点（即operand[operandOffset]处）的值和导数的数组
      result - 必须存储结果的数组（对于组合函数，结果数组不能是输入数组）
      resultOffset - 结果在其数组中的偏移量

    • taylor

      public double taylor(double[] ds, int dsOffset, double... delta) throws MathRuntimeException
      计算导数结构的泰勒展开。
      参数:
      ds - 包含导数结构的数组
      dsOffset - 导数结构在其数组中的偏移量
      delta - 参数偏移量（Δx，Δy，...）
      返回:
      在 x + Δx，y + Δy，... 处的泰勒展开值
      抛出:
      MathRuntimeException - 如果阶乘变得太大

    • taylor

      @SafeVarargs public final <T extends CalculusFieldElement<T>> T taylor(T[] ds, int dsOffset, T... delta) throws MathRuntimeException
      计算导数结构的泰勒展开。
      类型参数:
      T - 函数参数和值的类型
      参数:
      ds - 包含导数结构的数组
      dsOffset - 导数结构在其数组中的偏移量
      delta - 参数偏移量（Δx，Δy，...）
      返回:
      在 x + Δx，y + Δy，... 处的泰勒展开值
      抛出:
      MathRuntimeException - 如果阶乘变得太大

    • taylor

      public <T extends CalculusFieldElement<T>> T taylor(T[] ds, int dsOffset, double... delta) throws MathRuntimeException
      计算导数结构的泰勒展开。
      类型参数:
      T - 函数参数和值的类型
      参数:
      ds - 包含导数结构的数组
      dsOffset - 导数结构在其数组中的偏移量
      delta - 参数偏移量（Δx，Δy，...）
      返回:
      在 x + Δx，y + Δy，... 处的泰

    • rebase

      public void rebase(double[] ds, int dsOffset, DSCompiler baseCompiler, double[] p, double[] result, int resultOffset)
      重新基于低级参数函数重新定位导数结构。
      参数:
      ds - 保存导数结构的数组
      dsOffset - 导数结构在其数组中的偏移量
      baseCompiler - 与低级参数函数相关联的编译器
      p - 保存低级参数函数的数组（一个扁平数组）
      result - 必须存储结果的数组（对于组合，结果数组不能是输入）
      resultOffset - 结果在其数组中的偏移量
      从以下版本开始:
      2.2

    • rebase

      public <T extends CalculusFieldElement<T>> void rebase(T[] ds, int dsOffset, DSCompiler baseCompiler, T[] p, T[] result, int resultOffset)
      重新基于低级参数函数重新定位导数结构。
      类型参数:
      T - 字段元素的类型
      参数:
      ds - 保存导数结构的数组
      dsOffset - 导数结构在其数组中的偏移量
      baseCompiler - 与低级参数函数相关联的编译器
      p - 保存低级参数函数的数组（一个扁平数组）
      result - 必须存储结果的数组（对于组合，结果数组不能是输入）
      resultOffset - 结果在其数组中的偏移量
      从以下版本开始:
      2.2

    • checkCompatibility

      public void checkCompatibility(DSCompiler compiler) throws MathIllegalArgumentException
      检查规则集的兼容性。
      参数:
      compiler - 用于检查与实例是否兼容的其他编译器
      抛出:
      MathIllegalArgumentException - 如果自由参数或阶数不一致