Module jdk.incubator.vector
Package jdk.incubator.vector

Class DoubleVector

java.lang.Object
jdk.incubator.vector.Vector<Double>
jdk.incubator.vector.DoubleVector
public abstract class DoubleVector extends Vector<Double>
DoubleVector 依赖于Java平台的预览功能：
仅当启用预览功能时，程序才能使用DoubleVector。
预览功能可能会在未来的版本中被移除，或升级为Java平台的永久功能。
代表有序不可变序列double值的专用Vector。

  • Field Details

  • Method Details

    • zero

      public static DoubleVector zero(VectorSpecies<Double> species)
      Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
      参数:
      species - 所需零向量的species
      返回:
      一个零向量

    • broadcast

      public abstract DoubleVector broadcast(double e)
      返回与此向量相同species的向量，其中所有lane元素均设置为原始值e。当前向量的内容被丢弃；只有species与此操作相关。

      此方法返回此表达式的值：DoubleVector.broadcast(this.species(), e)。

      API注释:
      与超类型Vector中名为broadcast()的类似方法不同，此方法不需要验证其参数，并且不会抛出IllegalArgumentException。因此，此方法优于超类型方法。
      参数:
      e - 要广播的值
      返回:
      所有lane元素均设置为原始值e的向量
      参见:

    • broadcast

      public static DoubleVector broadcast(VectorSpecies<Double> species, double e)
      返回与给定species相同的向量，其中所有lane元素均设置为原始值e。
      参数:
      species - 所需向量的species
      e - 要广播的值
      返回:
      所有lane元素均设置为原始值e的向量
      参见:

    • broadcast

      public abstract DoubleVector broadcast(long e)
      返回一个与当前向量相同类型的向量，其中所有的lane元素都设置为原始值e。当前向量的内容将被丢弃；只有类型对这个操作是相关的。

      该方法返回以下表达式的值：EVector.broadcast(this.species(), (ETYPE)e)，其中EVector是特定于该向量元素类型ETYPE的向量类。

      必须确保long值e可以准确表示为该向量类型ETYPE，即e==(long)(ETYPE)e。如果违反此规则，问题不会在静态时被检测到，但会在运行时抛出IllegalArgumentException。因此，该方法在一定程度上减弱了对立即常量和其他标量的静态类型检查，但通过提高通用API的表达能力来弥补这一点。请注意，范围在[-128..127]的e值始终是可接受的，因为每个ETYPE都将接受每个byte值。

      指定者：
      broadcast 在类 Vector<Double>
      API注释：
      当使用像DoubleVector这样的向量子类型时，通常会选择更强类型的方法。可以使用强制转换来明确选择：v.broadcast((double)e)。这两个表达式将产生数值上相同的结果。
      参数：
      e - 要广播的值
      返回：
      一个向量，其中所有的lane元素都设置为原始值e
      参见：

    • broadcast

      public static DoubleVector broadcast(VectorSpecies<Double> species, long e)
      返回一个给定类型的向量，其中所有的lane元素都设置为原始值e。必须确保long值可以准确表示为向量类型ETYPE，即e==(long)(ETYPE)e。
      参数：
      species - 所需向量的类型
      e - 要广播的值
      返回：
      一个向量，其中所有的lane元素都设置为原始值e
      抛出：
      IllegalArgumentException - 如果给定的long值无法被向量的ETYPE表示
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Unary op)
      操作该向量的lane值。这是一个逐lane一元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于处理lane值的操作
      返回：
      将操作逐lane应用于输入向量的结果
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Unary op, VectorMask<Double> m)
      操作该向量的lane值，通过掩码控制lane元素的选择。这是一个逐lane一元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于处理lane值的操作
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于输入向量的结果
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Binary op, Vector<Double> v)
      将该向量的对应lane值与第二个输入向量的对应lane值组合。这是一个逐lane二元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于组合lane值的操作
      v - 输入向量
      返回：
      将操作逐lane应用于两个输入向量的结果
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> m)
      将该向量的对应lane值与第二个输入向量的对应lane值组合，通过掩码控制lane元素的选择。这是一个逐lane二元操作，将所选操作应用于每个lane。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于组合lane值的操作
      v - 第二个输入向量
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于两个输入向量的结果
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Binary op, double e)
      将该向量的lane值与广播标量值组合。这是一个逐lane二元操作，将所选操作应用于每个lane。返回值将等于这个表达式：this.lanewise(op, this.broadcast(e))。
      参数：
      op - 用于处理lane值的操作
      e - 输入标量
      返回：
      将操作逐lane应用于两个输入向量的结果
      抛出：
      UnsupportedOperationException - 如果该向量不支持请求的操作
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Binary op, double e, VectorMask<Double> m)
      将该向量的lane值与广播标量值组合，通过掩码控制lane元素的选择。这是一个掩码逐lane二元操作，将所选操作应用于每个lane。返回值将等于这个表达式：this.lanewise(op, this.broadcast(e), m)。
      参数：
      op - 用于处理lane值的操作
      e - 输入标量
      m - 控制lane选择的掩码
      返回：
      将操作逐lane应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果该向量不支持请求的操作
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Binary op, long e)
      将此向量的通道值与广播标量的值相结合。这是一种逐通道二进制操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e))。
      指定者：
      lanewise 在类 Vector<Double>
      API 注意：
      当使用像DoubleVector这样的向量子类型时，通常会选择更强类型的方法。可以使用强制转换来明确选择： v.lanewise(op,(double)e)。这两个表达式将产生数值上相同的结果。
      参数：
      op - 用于组合通道值的操作
      e - 输入标量
      返回：
      将操作逐通道应用于输入向量和标量的结果
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Binary op, long e, VectorMask<Double> m)
      将此向量的对应通道值与第二个输入向量的通道值组合，通过掩码控制通道元素的选择。这是一种逐通道二进制操作，将所选操作应用于每个通道。第二个操作数是广播整数值。返回值将等于此表达式：this.lanewise(op, this.broadcast(e), m)。
      指定者：
      lanewise 在类 Vector<Double>
      API 注意：
      当使用像DoubleVector这样的向量子类型时，通常会选择更强类型的方法。可以使用强制转换来明确选择： v.lanewise(op,(double)e,m)。这两个表达式将产生数值上相同的结果。
      参数：
      op - 用于组合通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于输入向量和标量的结果
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2)
      将此向量的对应通道值与第二个和第三个输入向量的通道值组合。这是一种逐通道三元操作，将所选操作应用于每个通道。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于组合通道值的操作
      v1 - 第二个输入向量
      v2 - 第三个输入向量
      返回：
      将操作逐通道应用于三个输入向量的结果
      参见：

    • lanewise

      public abstract DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m)
      将此向量的对应通道值与第二个和第三个输入向量的通道值组合，通过掩码控制通道元素的选择。这是一种逐通道三元操作，将所选操作应用于每个通道。
      指定者：
      lanewise 在类 Vector<Double>
      参数：
      op - 用于组合通道值的操作
      v1 - 第二个输入向量
      v2 - 第三个输入向量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于三个输入向量的结果
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, double e2)
      将此向量的通道值与两个广播标量的值相结合。这是一种逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), this.broadcast(e2))。
      参数：
      op - 用于组合通道值的操作
      e1 - 第一个输入标量
      e2 - 第二个输入标量
      返回：
      将操作逐通道应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, double e2, VectorMask<Double> m)
      将此向量的通道值与两个广播标量的值相结合，通过掩码控制通道元素的选择。这是一种带掩码的逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)。
      参数：
      op - 用于组合通道值的操作
      e1 - 第一个输入标量
      e2 - 第二个输入标量
      m - 控制通道选择的掩码
      返回：
      将操作逐通道应用于输入向量和标量的结果
      抛出：
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见：

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2)
      将此向量的通道值与另一个向量的值和广播标量的值相结合。这是一种逐通道三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, v1, this.broadcast(e2))。
      参数:
      op - 用于合并通道值的操作
      v1 - 另一个输入向量
      e2 - 输入标量
      返回:
      将操作逐通道应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> m)
      将此向量的通道值与另一个向量和广播标量的值组合，通过掩码控制通道元素的选择。这是一种掩码通道逐一三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, v1, this.broadcast(e2), m)。
      参数:
      op - 用于合并通道值的操作
      v1 - 另一个输入向量
      e2 - 输入标量
      m - 控制通道选择的掩码
      返回:
      将操作逐通道应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2)
      将此向量的通道值与另一个向量和广播标量的值组合。这是一种通道逐一三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), v2)。
      参数:
      op - 用于合并通道值的操作
      e1 - 输入标量
      v2 - 另一个输入向量
      返回:
      将操作逐通道应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

      public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> m)
      将此向量的通道值与另一个向量和广播标量的值组合，通过掩码控制通道元素的选择。这是一种掩码通道逐一三元操作，将所选操作应用于每个通道。返回值将等于此表达式：this.lanewise(op, this.broadcast(e1), v2, m)。
      参数:
      op - 用于合并通道值的操作
      e1 - 输入标量
      v2 - 另一个输入向量
      m - 控制通道选择的掩码
      返回:
      将操作逐通道应用于输入向量和标量的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • add

      public final DoubleVector add(Vector<Double> v)
      将此向量添加到第二个输入向量。这是一种通道逐一二元操作，将原始加法操作（+）应用于每对对应的通道值。该方法也等同于表达式lanewise(ADD, v)。

      作为一个全功能命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者:
      add 在类 Vector<Double>
      参数:
      v - 第二个输入向量
      返回:
      将此向量添加到第二个输入向量的结果
      参见:

    • add

      public final DoubleVector add(double e)
      将此向量添加到输入标量的广播值。这是一种通道逐一二元操作，将原始加法操作（+）应用于每个通道。该方法也等同于表达式lanewise(ADD, e)。
      参数:
      e - 输入标量
      返回:
      将此向量的每个通道与标量相加的结果
      参见:

    • add

      public final DoubleVector add(Vector<Double> v, VectorMask<Double> m)
      将此向量添加到第二个输入向量，根据掩码选择通道。这是一种掩码通道逐一二元操作，将原始加法操作（+）应用于每对对应的通道值。对于掩码中未设置的通道，原始操作被抑制，此向量保留该通道中存储的原始值。该方法也等同于表达式lanewise(ADD, v, m)。

      作为一个全功能命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者:
      add 在类 Vector<Double>
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回:
      将此向量添加到给定向量的结果
      参见:

    • add

      public final DoubleVector add(double e, VectorMask<Double> m)
      将此向量添加到输入标量的广播值，根据掩码选择通道元素。这是一种掩码通道逐一二元操作，将原始加法操作（+）应用于每个通道。该方法也等同于表达式lanewise(ADD, s, m)。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回:
      将此向量的每个通道与标量相加的结果
      参见:

    • sub

      public final DoubleVector sub(Vector<Double> v)
      从这个向量中减去第二个输入向量。这是一种逐个通道的二进制操作，对应每对相应通道值应用原始减法操作（-）。该方法也等同于表达式lanewise(SUB, v)。

      作为一个全服务命名操作，该方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      sub 在类 Vector<Double>
      参数：
      v - 第二个输入向量
      返回：
      减去第二个输入向量后的结果
      参见：

    • sub

      public final DoubleVector sub(double e)
      从这个向量中减去输入标量。这是一种掩码通道逐个二进制操作，对每个通道应用原始减法操作（-）。该方法也等同于表达式lanewise(SUB, e)。
      参数：
      e - 输入标量
      返回：
      减去该向量每个通道的标量的结果
      参见：

    • sub

      public final DoubleVector sub(Vector<Double> v, VectorMask<Double> m)
      通过掩码从这个向量中减去第二个输入向量。这是一种掩码通道逐个二进制操作，对每对应通道值应用原始减法操作（-）。对于掩码中未设置的任何通道，原始操作被抑制，该向量保留该通道中存储的原始值。该方法也等同于表达式lanewise(SUB, v, m)。

      作为一个全服务命名操作，该方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      sub 在类 Vector<Double>
      参数：
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回：
      减去第二个输入向量后的结果
      参见：

    • sub

      public final DoubleVector sub(double e, VectorMask<Double> m)
      通过掩码从这个向量中减去输入标量。这是一种掩码通道逐个二进制操作，对每个通道应用原始减法操作（-）。该方法也等同于表达式lanewise(SUB, s, m)。
      参数：
      e - 输入标量
      m - 控制通道选择的掩码
      返回：
      减去该向量每个通道的标量的结果
      参见：

    • mul

      public final DoubleVector mul(Vector<Double> v)
      将这个向量乘以第二个输入向量。这是一种逐个通道的二进制操作，对应每对相应通道值应用原始乘法操作（*）。该方法也等同于表达式lanewise(MUL, v)。

      作为一个全服务命名操作，该方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      mul 在类 Vector<Double>
      参数：
      v - 第二个输入向量
      返回：
      将这个向量乘以第二个输入向量的结果
      参见：

    • mul

      public final DoubleVector mul(double e)
      将这个向量乘以输入标量的广播。这是一种逐个通道的二进制操作，对每个通道应用原始乘法操作（*）。该方法也等同于表达式lanewise(MUL, e)。
      参数：
      e - 输入标量
      返回：
      将这个向量乘以给定标量的结果
      参见：

    • mul

      public final DoubleVector mul(Vector<Double> v, VectorMask<Double> m)
      通过掩码将这个向量乘以第二个输入向量。这是一种掩码通道逐个二进制操作，对每对应通道值应用原始乘法操作（*）。对于掩码中未设置的任何通道，原始操作被抑制，该向量保留该通道中存储的原始值。该方法也等同于表达式lanewise(MUL, v, m)。

      作为一个全服务命名操作，该方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      mul 在类 Vector<Double>
      参数：
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回：
      将这个向量乘以给定向量的结果
      参见：

    • mul

      public final DoubleVector mul(double e, VectorMask<Double> m)
      通过掩码将这个向量乘以输入标量的广播，选择由掩码控制的通道元素。这是一种掩码通道逐个二进制操作，对每个通道应用原始乘法操作（*）。该方法也等同于表达式lanewise(MUL, s, m)。
      参数：
      e - 输入标量
      m - 控制通道选择的掩码
      返回：
      将该向量每个通道乘以标量的结果
      参见：

    • div

      public final DoubleVector div(Vector<Double> v)
      将此向量除以第二个输入向量。这是一种逐个通道的二进制操作，对应每对通道值应用原始除法操作（/）。此方法也等同于表达式lanewise(DIV, v)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      div 在类 Vector<Double>
      API 注意：
      因为底层标量运算符是IEEE浮点数，实际上除以零不会抛出异常，而会产生有符号的无穷大或NaN。
      参数：
      v - 第二个输入向量
      返回：
      将此向量除以第二个输入向量的结果
      参见：

    • div

      public final DoubleVector div(double e)
      将此向量除以输入标量的广播。这是一种逐个通道的二进制操作，对每个通道应用原始除法操作（/）。此方法也等同于表达式lanewise(DIV, e)。
      API 注意：
      因为底层标量运算符是IEEE浮点数，实际上除以零不会抛出异常，而会产生有符号的无穷大或NaN。
      参数：
      e - 输入标量
      返回：
      将此向量的每个通道除以标量的结果
      参见：

    • div

      public final DoubleVector div(Vector<Double> v, VectorMask<Double> m)
      在掩码的控制下，将此向量除以第二个输入向量。这是一种逐个通道的二进制操作，对应每对通道值应用原始除法操作（/）。对于掩码中未设置的任何通道，原始操作被抑制，此向量保留该通道中存储的原始值。此方法也等同于表达式lanewise(DIV, v, m)。

      作为一个全服务命名操作，此方法有掩码和非掩码的重载，并且（在子类中）还有标量广播的重载（包括掩码和非掩码）。

      指定者：
      div 在类 Vector<Double>
      API 注意：
      因为底层标量运算符是IEEE浮点数，实际上除以零不会抛出异常，而会产生有符号的无穷大或NaN。
      参数：
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回：
      将此向量除以第二个输入向量的结果
      参见：

    • div

      public final DoubleVector div(double e, VectorMask<Double> m)
      在掩码控制的情况下，将此向量除以输入标量的广播，选择由掩码控制的通道元素。这是一种掩码的逐个通道的二进制操作，对每个通道应用原始除法操作（/）。此方法也等同于表达式lanewise(DIV, s, m)。
      API 注意：
      因为底层标量运算符是IEEE浮点数，实际上除以零不会抛出异常，而会产生有符号的无穷大或NaN。
      参数：
      e - 输入标量
      m - 控制通道选择的掩码
      返回：
      将此向量的每个通道除以标量的结果
      参见：

    • min

      public final DoubleVector min(Vector<Double> v)
      计算此向量和第二个输入向量中较小的值。这是一种逐个通道的二进制操作，对应每对通道值应用操作Math.min()。此方法也等同于表达式lanewise(MIN, v)。
      指定者：
      min 在类 Vector<Double>
      API 注意：
      对于此方法，浮点数负零-0.0被视为与默认值（正零）不同且小于默认值的值。
      参数：
      v - 第二个输入向量
      返回：
      此向量和第二个输入向量的每个通道的最小值
      参见：

    • min

      public final DoubleVector min(double e)
      计算此向量和输入标量的广播中较小的值。这是一种逐个通道的二进制操作，对应每对通道值应用操作Math.min()。此方法也等同于表达式lanewise(MIN, e)。
      API 注意：
      对于此方法，浮点数负零-0.0被视为与默认值（正零）不同且小于默认值的值。
      参数：
      e - 输入标量
      返回：
      将此向量乘以给定标量的结果
      参见：

    • max

      public final DoubleVector max(Vector<Double> v)
      计算此向量和第二个输入向量中较大的值。这是一种逐个通道的二进制操作，对应每对通道值应用操作Math.max()。此方法也等同于表达式lanewise(MAX, v)。

      这不是像add()那样的全服务命名操作。此操作的掩码版本不是直接可用的，但可以通过lanewise的掩码版本获得。子类定义了此方法的额外标量广播重载。

      指定者:
      max 在类 Vector<Double>中
      API注释:
      对于此方法，浮点负零-0.0被视为与默认值（正零）不同且小于默认值。
      参数:
      v - 第二个输入向量
      返回值:
      此向量和第二个输入向量的每个元素的最大值
      参见:

    • max

      public final DoubleVector max(double e)
      计算此向量和输入标量的广播之间的较大值。这是一种逐个元素的二元操作，将操作Math.max()应用于每对对应的元素值。此方法也等同于表达式lanewise(MAX, e)。
      API注释:
      对于此方法，浮点负零-0.0被视为与默认值（正零）不同且小于默认值。
      参数:
      e - 输入标量
      返回值:
      将此向量乘以给定标量的结果
      参见:

    • pow

      public final DoubleVector pow(Vector<Double> b)
      将此向量提升到第二个输入向量的幂。这是一种逐个元素的二元操作，将符合Math.pow(a,b)规范的操作应用于每对对应的元素值。此方法也等同于表达式lanewise(POW, b)。

      这不是像add那样的全服务命名操作。此操作的掩码版本不直接可用，但可以通过lanewise的掩码版本获得。

      参数:
      b - 用于提升此向量的向量指数
      返回值:
      此向量的b次幂
      参见:

    • pow

      public final DoubleVector pow(double b)
      将此向量提升到标量幂。这是一种逐个元素的二元操作，将符合Math.pow(a,b)规范的操作应用于每对对应的元素值。此方法也等同于表达式lanewise(POW, b)。
      参数:
      b - 用于提升此向量的标量指数
      返回值:
      此向量的b次幂
      参见:

    • neg

      public final DoubleVector neg()
      取反此向量。这是一种逐个元素的一元操作，将原始取反操作（-x）应用于每个输入元素。此方法也等同于表达式lanewise(NEG)。
      指定者:
      neg 在类 Vector<Double>中
      返回值:
      此向量的取反
      参见:

    • abs

      public final DoubleVector abs()
      返回此向量的绝对值。这是一种逐个元素的一元操作，将方法Math.abs应用于每个输入元素。此方法也等同于表达式lanewise(ABS)。
      指定者:
      abs 在类 Vector<Double>中
      返回值:
      此向量的绝对值
      参见:

    • sqrt

      public final DoubleVector sqrt()
      计算此向量的平方根。这是一种逐个元素的一元操作，将符合Math.sqrt(a)规范的操作应用于每个元素值。此方法也等同于表达式lanewise(SQRT)。
      返回值:
      此向量的平方根
      参见:

    • eq

      public final VectorMask<Double> eq(Vector<Double> v)
      测试此向量是否等于另一个输入向量。这是一种逐个元素的二元测试操作，将原始等于操作（==）应用于每对对应的元素值。结果与compare(VectorOperators.EQ, v)相同。
      指定者:
      eq 在类 Vector<Double>中
      参数:
      v - 第二个输入向量
      返回值:
      测试每个元素是否等于第二个输入向量的掩码结果
      参见:

    • eq

      public final VectorMask<Double> eq(double e)
      测试此向量是否等于输入标量。这是一种逐个元素的二元测试操作，将原始等于操作（==）应用于每个元素。结果与compare(VectorOperators.Comparison.EQ, e)相同。
      参数:
      e - 输入标量
      返回值:
      测试此向量是否等于e的结果掩码
      参见:

    • lt

      public final VectorMask<Double> lt(Vector<Double> v)
      测试此向量是否小于另一个输入向量。这是一种逐个元素的二元测试操作，将原始小于操作（<）应用于每个元素。结果与compare(VectorOperators.LT, v)相同。
      指定者:
      lt 在类 Vector<Double>中
      参数:
      v - 第二个输入向量
      返回值:
      测试每个通道，以确定此向量是否小于第二个输入向量的掩码结果
      参见:

    • lt

      public final VectorMask<Double> lt(double e)
      测试此向量是否小于输入标量。这是一种通道级的二进制测试操作，将原始小于操作（<）应用于每个通道。结果与compare(VectorOperators.LT, e)相同。
      参数:
      e - 输入标量
      返回值:
      测试此向量是否小于输入标量的掩码结果
      参见:

    • test

      public abstract VectorMask<Double> test(VectorOperators.Test op)
      根据给定操作测试此向量的通道。这是一种通道级的一元测试操作，将给定的测试操作应用于每个通道值。
      指定者:
      test 在类 Vector<Double>中
      参数:
      op - 用于测试通道值的操作
      返回值:
      测试此向量的通道的掩码结果，根据所选的测试运算符
      参见:

    • test

      public abstract VectorMask<Double> test(VectorOperators.Test op, VectorMask<Double> m)
      根据给定操作测试此向量的选定通道。这是一种带掩码的通道级一元测试操作，将给定的测试操作应用于每个通道值。返回的结果等同于表达式test(op).and(m)。
      指定者:
      test 在类 Vector<Double>中
      参数:
      op - 用于测试通道值的操作
      m - 控制通道选择的掩码
      返回值:
      测试此向量的通道的掩码结果，根据所选的测试运算符，并且仅在掩码选择的通道中
      参见:

    • compare

      public abstract VectorMask<Double> compare(VectorOperators.Comparison op, Vector<Double> v)
      通过将其与另一个输入向量进行比较，根据给定的比较操作测试此向量。这是一种通道级的二进制测试操作，将给定的比较操作应用于每对相应的通道值。
      指定者:
      compare 在类 Vector<Double>中
      参数:
      op - 用于比较通道值的操作
      v - 第二个输入向量
      返回值:
      测试每个通道，以确定此向量是否与输入进行比较的掩码结果，根据所选的比较运算符
      参见:

    • compare

      public abstract VectorMask<Double> compare(VectorOperators.Comparison op, double e)
      通过将其与输入标量进行比较，根据给定的比较操作测试此向量。这是一种通道级的二进制测试操作，将比较操作应用于每个通道。

      结果与compare(op, broadcast(species(), e))相同。也就是说，标量可以被视为广播到相同种类的向量，然后根据所选的比较操作与原始向量进行比较。

      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      返回值:
      测试每个通道，以确定此向量是否与输入进行比较的掩码结果，根据所选的比较运算符
      参见:

    • compare

      public final VectorMask<Double> compare(VectorOperators.Comparison op, double e, VectorMask<Double> m)
      通过将其与输入标量进行比较，在由掩码选择的通道中根据给定的比较操作测试此向量。这是一种带掩码的通道级二进制测试操作，将给定的比较操作应用于每对相应的通道值。返回的结果等同于表达式compare(op,s).and(m)。
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      测试每个通道，以确定此向量是否与输入进行比较的掩码结果，根据所选的比较运算符，并且仅在掩码选择的通道中
      参见:

    • compare

      public abstract VectorMask<Double> compare(VectorOperators.Comparison op, long e)
      通过将其与输入标量进行比较，根据给定的比较操作测试此向量。这是一种通道级的二进制测试操作，将给定的比较操作应用于每个通道值，与广播值配对。

      结果与this.compare(op, this.broadcast(e))相同。也就是说，标量可以被视为广播到相同种类的向量，然后根据所选的比较操作与原始向量进行比较。

      指定者:
      compare 在类 Vector<Double>中
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      返回值:
      测试每个通道，以确定此向量是否与输入进行比较的掩码结果，根据所选的比较运算符
      参见:

    • compare

      public final VectorMask<Double> compare(VectorOperators.Comparison op, long e, VectorMask<Double> m)
      通过将其与输入标量进行比较，在由掩码选择的通道中根据给定的比较操作测试此向量。这是一种带掩码的通道级二进制测试操作，将给定的比较操作应用于每个通道值，与广播值配对。返回的结果等同于表达式compare(op,e).and(m)。
      指定者:
      compare 在类 Vector<Double>中
      参数:
      op - 用于比较通道值的操作
      e - 输入标量
      m - 控制通道选择的掩码
      返回值:
      测试每个通道，以确定此向量是否与输入进行比较的掩码结果，根据所选的比较运算符，并且仅在掩码选择的通道中
      参见:

    • blend

      public abstract DoubleVector blend(Vector<Double> v, VectorMask<Double> m)
      用第二个输入向量的相应通道替换此向量的选定通道，受掩码控制。这是一种受掩码控制的通道级二进制操作，它从两个输入中选择每个通道的值。
      • 对于掩码中设置的任何通道，新的通道值取自第二个输入向量，并替换此向量的该通道中的任何值。
      • 对于掩码中未设置的任何通道，替换被抑制，此向量保留该通道中原始存储的值。
      以下伪代码说明了这种行为： 
      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 Vector<E> b = ...;
 b.check(species);
 VectorMask<E> m = ...;
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     if (m.laneIsSet(i)) {
         ar[i] = b.lane(i);
     }
 }
 return EVector.fromArray(s, ar, 0);
      指定者：
      blend 在类 Vector<Double>
      参数：
      v - 第二个输入向量，包含替换通道值
      m - 控制从第二个输入向量选择通道的掩码
      返回：
      将此向量的通道元素与第二个输入向量的通道元素混合的结果

    • addIndex

      public abstract DoubleVector addIndex(int scale)
      将此向量的通道添加到其相应的通道编号，乘以给定常数。这是一种通道级一元操作，对于每个通道N，计算缩放后的索引值N*scale，并将其添加到当前向量的通道N中的值。

      缩放必须不要太大，元素大小也不要太小，以至于在计算任何N*scale或VLENGTH*scale时会发生溢出，当使用向量通道类型ETYPE表示结果时。

      以下伪代码说明了这种行为：

      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     long d = (long)i * scale;
     if (d != (ETYPE) d)  throw ...;
     ar[i] += (ETYPE) d;
 }
 long d = (long)ar.length * scale;
 if (d != (ETYPE) d)  throw ...;
 return EVector.fromArray(s, ar, 0);
      指定者：
      addIndex 在类 Vector<Double>
      参数：
      scale - 乘以每个通道索引N的数字，通常为1
      返回：
      将每个通道元素递增其相应的通道索引N，乘以scale的结果

    • blend

      public final DoubleVector blend(double e, VectorMask<Double> m)
      用标量值替换此向量的选定通道，受掩码控制。这是一种受掩码控制的通道级二进制操作，它从两个输入中选择每个通道的值。返回的结果等于表达式blend(broadcast(e),m)。
      参数：
      e - 输入标量，包含替换通道值
      m - 控制标量通道选择的掩码
      返回：
      将此向量的通道元素与标量值混合的结果

    • blend

      public final DoubleVector blend(long e, VectorMask<Double> m)
      用标量值替换此向量的选定通道，受掩码控制。这是一种受掩码控制的通道级二进制操作，它从两个输入中选择每个通道的值。返回的结果等于表达式blend(broadcast(e),m)。
      指定者：
      blend 在类 Vector<Double>
      参数：
      e - 输入标量，包含替换通道值
      m - 控制标量通道选择的掩码
      返回：
      将此向量的通道元素与标量值混合的结果

    • slice

      public abstract DoubleVector slice(int origin, Vector<Double> v1)
      从当前向量的给定origin通道开始，切片相邻通道的段，并继续（如有必要）到紧随其后的向量。将VLENGTH个通道块提取到自己的向量中并返回。

      这是一种跨通道操作，将通道元素从当前向量和第二个向量移至前端。这两个向量可以被视为长度为2*VLENGTH的组合“背景”，从中提取一个切片。输出向量中编号为N的通道是从输入向量的通道origin+N复制的，如果该通道存在，则从第二个向量的通道origin+N-VLENGTH复制（保证存在）。

      origin值必须在包含范围0..VLENGTH内。作为极端情况，v.slice(0,w)和v.slice(VLENGTH,w)分别返回v和w。

      参数：
      origin - 转移到切片中的第一个输入通道
      v1 - 逻辑上与第一个向量连接，然后取切片（如果省略，默认为零）
      返回：
      从指定起点开始，从此向量中取出的长度为VLENGTH的连续通道块，并继续（如有必要）到第二个向量
      参见：

    • slice

      public final DoubleVector slice(int origin, Vector<Double> w, VectorMask<Double> m)
      在受掩码控制下，从当前向量的给定origin通道开始，切片相邻通道的段，并继续（如有必要）到紧随其后的向量。将VLENGTH个通道块提取到自己的向量中并返回。结果向量中未设置的通道将为零。掩码中设置的通道将包含从所选通道的this或v1复制的数据。

      这是一种跨通道操作，将通道元素从当前向量和第二个向量移至前端。这两个向量可以被视为长度为2*VLENGTH的组合“背景”，从中提取一个切片。返回的结果等于表达式broadcast(0).blend(slice(origin,v1),m)。

      指定者：
      slice 在类 Vector<Double>
      参数：
      origin - 转移到切片中的第一个输入通道
      w - 逻辑上与第一个向量连接，然后取切片（如果省略，默认为零）
      m - 控制通道选择进入结果向量的掩码
      返回：
      从指定起点开始，从此向量中取出的长度为VLENGTH的连续通道块，并继续（如有必要）到第二个向量
      参见：

    • slice

      public abstract DoubleVector slice(int origin)
      从当前向量的给定origin通道开始，切片相邻通道的段。从一个向量中提取一个长度为VLENGTH的通道块，可能填充零通道，并返回。这是一个方便的方法，从一个单一向量中切片，针对零通道的扩展背景。它等同于slice (origin, broadcast(0))。也可以简单地将其视为从后向前通道的跨通道移位，零填充在向量末尾的空通道中。在这种观点下，移位计数为origin。
      参数：
      origin - 转移到切片中的第一个输入通道
      返回：
      最后的VLENGTH-origin个输入通道，从第一个输出通道开始放置，末尾填充零
      参见：

    • unslice

      public abstract DoubleVector unslice(int origin, Vector<Double> w, int part)
      反转slice()，将当前向量作为一个切片插入到另一个“背景”输入向量中，该向量被视为假设的后续slice()操作的一个输入。

      这是一个跨通道操作，将当前向量的通道元素向后排列，并将它们插入到逻辑背景向量对中。然而，只返回一对中的一个。背景由复制第二个输入向量形成。（但是，输出永远不会包含来自同一输入通道的两个重复项。）输入向量中编号为N的通道被复制到第一个背景向量的通道origin+N中，如果该通道存在，则复制到第二个背景向量的通道origin+N-VLENGTH中（保证存在）。更新后插入切片的第一个或第二个背景向量将被返回。零或一的part数选择第一个或第二个更新后的背景向量。

      origin值必须在包含范围0..VLENGTH内。作为极端情况，v.unslice(0,w,0)和v.unslice(VLENGTH,w,1)都返回v，而v.unslice(0,w,1)和v.unslice(VLENGTH,w,0)都返回w。

      指定者：
      unslice 在类 Vector<Double>
      参数：
      origin - 接收切片的第一个输出通道
      w - 将接收插入切片的“背景”向量（作为两个副本），如果它们在m中被设置
      part - 结果的部分编号（零或一）
      返回：
      由插入此向量到指定起始位置的第一个或第二个背景向量对w更新后的背景向量之一
      参见：

    • unslice

      public abstract DoubleVector unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m)
      反转slice()，在掩码的控制下将当前向量作为一个切片插入到另一个“背景”输入向量中，该向量被视为假设的后续slice()操作的一个输入。

      这是一个跨通道操作，将当前向量的通道元素向前排列，并将其通道（由掩码选择）插入到逻辑背景向量对中。与此方法的无掩码版本相比，只返回一对中的一个，由part数选择。对于掩码选择的每个通道N，如果该通道存在，则将通道值复制到第一个背景向量的通道origin+N中，否则将通道值复制到第二个背景向量的通道origin+N-VLENGTH中（保证存在）。如果相应的输入通道N在掩码中未设置，则背景通道保留其原始值。更新后插入切片的第一个或第二个背景向量将被返回。零或一的part数选择第一个或第二个更新后的背景向量。

      指定者：
      unslice 在类 Vector<Double>
      参数：
      origin - 接收切片的第一个输出通道
      w - 将接收插入切片的“背景”向量（作为两个副本），如果它们在m中被设置
      part - 结果的部分编号（零或一）
      m - 控制从当前向量选择通道的掩码
      返回：
      由插入此向量的选定通道到指定起始位置的第一个或第二个背景向量对w更新后的背景向量之一
      参见：

    • unslice

      public abstract DoubleVector unslice(int origin)
      反转slice()，将当前向量作为一个切片插入到一个零通道值的“背景”输入中。与其他unslice()方法相比，此方法仅返回背景向量对中的第一个。这是一个便利方法，返回unslice (origin, broadcast(0), 0)的结果。它也可以简单地视为从早期到后期通道的跨通道移位，零填充在向量开头的空通道中。在这种视图中，移位计数为origin。
      指定者：
      unslice 在类 Vector<Double>
      参数：
      origin - 接收切片的第一个输出通道
      返回：
      从给定起始位置开始放置的第一个VLENGTH-origin输入通道，开头填充为零
      参见：

    • rearrange

      public abstract DoubleVector rearrange(VectorShuffle<Double> m)
      重新排列此向量的通道元素，选择受特定洗牌控制的通道。这是一个跨通道操作，重新排列此向量的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，输出通道N从输入向量的通道I获取值。
      指定者：
      rearrange 在类 Vector<Double>
      参数：
      m - 控制通道索引选择的洗牌
      返回：
      重新排列此向量的通道元素
      参见：

    • rearrange

      public abstract DoubleVector rearrange(VectorShuffle<Double> s, VectorMask<Double> m)
      重新排列此向量的通道元素，选择受特定洗牌和掩码控制的通道。这是一个跨通道操作，重新排列此向量的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，如果掩码被设置，则输出通道N从输入向量的通道I获取值。否则，输出通道N设置为零。

      此方法返回以下伪代码的值：

      
 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);
      指定者：
      rearrange 在类 Vector<Double>
      参数：
      s - 控制通道索引选择的洗牌
      m - 控制洗牌应用的掩码
      返回：
      重新排列此向量的通道元素
      参见：

    • rearrange

      public abstract DoubleVector rearrange(VectorShuffle<Double> s, Vector<Double> v)
      重新排列两个向量的通道元素，使用特定洗牌的正常和异常索引控制通道以引导数据。这是一个跨通道操作，重新排列两个输入向量（当前向量和第二个向量v）的通道元素。对于每个洗牌的通道N，以及每个洗牌中的通道源索引I=s.laneSource(N)，如果I>=0，则输出通道N从第一个向量的通道I获取值。否则，异常索引I通过添加VLENGTH进行包装，并用于索引第二个向量，索引为I+VLENGTH。

      此方法返回以下伪代码的值：

      
 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // 或者：r1 = this.rearrange(s, s.laneIsValid());
 Vector<E> r2 = v.rearrange(s.wrapIndexes());
 return r2.blend(r1,s.laneIsValid());
      指定者:
      rearrange 在类 Vector<Double>中
      参数:
      s - 控制来自两个输入向量的通道选择的洗牌
      v - 第二个输入向量
      返回:
      对此向量和第二个输入向量的通道元素重新排列
      参见:

    • compress

      public abstract DoubleVector compress(VectorMask<Double> m)
      压缩此向量的通道元素，选择受特定掩码控制的通道。这是一个跨通道操作，根据指定的掩码压缩此向量的通道元素。对于掩码的每个通道 N，如果通道 N 处的掩码被设置，则从输入向量的通道 N 选择元素并连续存储到输出向量中，从通道 0 开始。输出向量的所有上部剩余通道（如果有）都设置为零。
      指定者:
      compress 在类 Vector<Double>中
      参数:
      m - 控制压缩的掩码
      返回:
      此向量的压缩通道元素
      自:
      19

    • expand

      public abstract DoubleVector expand(VectorMask<Double> m)
      在受特定掩码控制的情况下，扩展此向量的通道元素。这是一个跨通道操作，根据指定的掩码将此向量的连续通道元素扩展到输出向量的通道中。对于掩码的每个通道 N，如果通道 N 处的掩码被设置，则从输入向量从通道 0 开始选择下一个连续元素，并将其存储到输出向量的通道 N 中。输出向量的其余通道（如果有）都设置为零。
      指定者:
      expand 在类 Vector<Double>中
      参数:
      m - 控制扩展的掩码
      返回:
      此向量的扩展通道元素
      自:
      19

    • selectFrom

      public abstract DoubleVector selectFrom(Vector<Double> v)
      使用存储在此向量的通道中的索引值，组装存储在第二个向量 v 中的值。因此，第二个向量充当一个表，其元素由当前向量中的索引选择。这是一个跨通道操作，根据此向量控制重新排列参数向量的通道元素。对于此向量的每个通道 N，以及此向量中通道值 I=this.lane(N)，输出通道 N 获取来自参数向量在通道 I 处的值。通过这种方式，结果仅包含存储在参数向量 v 中的值，但呈现的顺序取决于 this 中的索引值。结果与表达式 v.rearrange(this.toShuffle()) 相同。
      指定者:
      selectFrom 在类 Vector<Double>中
      参数:
      v - 提供结果值的向量
      返回:
      v 的通道元素重新排列
      参见:

    • selectFrom

      public abstract DoubleVector selectFrom(Vector<Double> s, VectorMask<Double> m)
      使用存储在此向量的通道中的索引值，组装存储在第二个向量中的值，受掩码控制。使用存储在此向量的通道中的索引值，组装存储在第二个向量 v 中的值。因此，第二个向量充当一个表，其元素由当前向量中的索引选择。在掩码中未设置的通道将接收零而不是来自表的值。这是一个跨通道操作，根据此向量和掩码控制重新排列参数向量的通道元素。结果与表达式 v.rearrange(this.toShuffle(), m) 相同。
      指定者:
      selectFrom 在类 Vector<Double>中
      参数:
      s - 提供结果值的向量
      m - 控制从 v 中选择的掩码
      返回:
      v 的通道元素重新排列
      参见:

    • fma

      public final DoubleVector fma(Vector<Double> b, Vector<Double> c)
      将此向量乘以第二个输入向量，并将结果与第三个向量相加。中间结果使用扩展精度，避免每个操作的四舍五入可能导致的精度损失。结果在数值上接近于 this.mul(b).add(c)，通常更接近真实的数学结果。这是一个按通道运算的三元操作，对每个通道应用符合 Math.fma(a,b,c) 规范的操作。此方法也等同于表达式 lanewise(FMA, b, c)。
      参数:
      b - 第二个输入向量，提供乘数值
      c - 第三个输入向量，提供加数值
      返回:
      此向量与第二个输入向量的乘积与第三个输入向量相加的结果，使用扩展精度进行中间结果计算
      参见:

    • fma

      public final DoubleVector fma(double b, double c)
      将此向量乘以标量乘数，并将结果与标量加数相加。中间结果使用扩展精度，避免每个操作的四舍五入可能导致的精度损失。结果在数值上接近于 this.mul(b).add(c)，通常更接近真实的数学结果。这是一个按通道运算的三元操作，对每个通道应用符合 Math.fma(a,b,c) 规范的操作。此方法也等同于表达式 lanewise(FMA, b, c)。
      参数:
      b - 标量乘数
      c - 标量加数
      返回:
      此向量与标量乘数相乘并与标量加数相加的结果，使用扩展精度进行中间结果计算
      参见:

    • reduceLanes

      public abstract double reduceLanes(VectorOperators.Associative op)
      返回从此向量的所有通道累积的值。这是一个关联的跨通道归约操作，将指定的操作应用于所有通道元素。

      一些归约操作不支持其操作数的任意重新排序，但由于其实用性而包含在此处。

      • 对于 FIRST_NONZERO，归约返回从编号最低的非零通道中的值。 （与 MAX 和 MIN 一样，浮点负零 -0.0 被视为与默认值正零不同的值。因此，即使存在非零通道值，第一个非零通道归约可能返回 -0.0。）
      • 对于 ADD 和 MUL，精确结果将反映对操作的任意操作顺序的选择，甚至可能随时间变化。有关更多详细信息，请参阅 浮点向量操作 部分。
      • 所有其他归约操作都是完全可交换和关联的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合通道值的操作
      返回:
      累积结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • reduceLanes

      public abstract double reduceLanes(VectorOperators.Associative op, VectorMask<Double> m)
      返回从此向量的选定通道累积的值，由掩码控制。这是一种关联的跨通道归约操作，将指定的操作应用于选定的通道元素。

      如果没有选择任何元素，则返回特定于操作的标识值。

      • 如果操作是ADD或FIRST_NONZERO，则标识值为正零，默认的double值。
      • 如果操作是MUL，则标识值为一。
      • 如果操作是MAX，则标识值为Double.NEGATIVE_INFINITY。
      • 如果操作是MIN，则标识值为Double.POSITIVE_INFINITY。

      一些归约操作不支持其操作数的任意重新排序，但由于其实用性而包含在此处。

      • 对于FIRST_NONZERO，归约返回从最低编号的非零通道返回的值。（与MAX和MIN一样，浮点负零-0.0被视为与默认值正零不同的值。因此，首个非零通道归约可能返回-0.0，即使存在非零通道值。）
      • 对于ADD和MUL，精确结果将反映对操作的任意操作顺序的选择，甚至可能随时间变化。有关更多详细信息，请参阅浮点向量上的操作部分。
      • 所有其他归约操作都是完全可交换和关联的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合通道值的操作
      m - 控制通道选择的掩码
      返回:
      从所选通道值累积的减少结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lane

      public abstract double lane(int i)
      获取通道索引i处的通道元素
      参数:
      i - 通道索引
      返回:
      通道索引i处的通道元素
      抛出:
      IllegalArgumentException - 如果索引超出范围（< 0 || >= length()）

    • withLane

      public abstract DoubleVector withLane(int i, double e)
      用值e替换此向量在通道索引i处的通道元素。这是一个跨通道操作，行为就像返回将此向量与广播e和在通道索引i处设置了一个通道的掩码的输入向量混合的结果。
      参数:
      i - 要替换的通道元素的通道索引
      e - 要放置的值
      返回:
      替换此向量在通道索引i处的通道元素为值e的结果。
      抛出:
      IllegalArgumentException - 如果索引超出范围（< 0 || >= length()）

    • toArray

      public final double[] toArray()
      返回一个包含所有通道值的double[]类型数组。数组长度与向量长度相同。数组元素按通道顺序存储。

      此方法的行为就像将此向量存储到分配的数组中（使用intoArray），并返回数组如下：

      
   double[] a = new double[this.length()];
   this.intoArray(a, 0);
   return a;
      指定者:
      toArray 在类 Vector<Double>
      返回:
      包含此向量通道值的数组
      参见:

    • toIntArray

      public final int[] toIntArray()
      返回一个包含所有通道值的int[]数组，转换为int类型。数组长度与向量长度相同。数组元素按通道顺序转换并存储。如果向量元素类型为float或double，当通道包含分数或超出范围值时，此操作可能失败。
      指定者:
      toIntArray 在类 Vector<Double>
      返回:
      包含此向量通道值的int[]数组
      参见:

    • toLongArray

      public final long[] toLongArray()
      返回一个包含所有通道值的long[]数组，转换为long类型。数组长度与向量长度相同。数组元素按通道顺序转换并存储。如果向量元素类型为float或double，当通道包含分数或超出范围值时，此操作可能失败。
      指定者:
      toLongArray 在类 Vector<Double>
      返回:
      包含此向量通道值的long[]数组
      参见:

    • toDoubleArray

      public final double[] toDoubleArray()
      返回一个包含所有通道值的double[]数组，转换为double类型。数组长度与向量长度相同。数组元素按通道顺序转换并存储。如果向量元素类型为long，此操作可能会丢失精度。
      指定者:
      toDoubleArray 在类 Vector<Double>
      实现注意:
      当在DoubleVector类型的向量上使用此方法时，这是toArray()的别名。在此方法用于DoubleVector类型的向量时，不会丢失精度。
      返回:
      包含此向量通道值的double[]数组，可能四舍五入为可表示的double值
      参见:

    • fromArray

      public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset)
      从偏移量开始从double[]类型数组加载向量。对于每个向量通道，其中N是向量通道索引，位于索引offset + N处的数组元素被放入结果向量的通道索引N处。
      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      返回:
      从数组加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中的任何通道N，offset+N < 0或offset+N >= a.length

    • fromArray

      public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m)
      从一个double[]类型的数组中加载一个向量，从偏移量开始并使用掩码。掩码未设置的通道将填充double的默认值（正零）。对于每个向量通道，其中N是向量通道索引，如果索引N处的掩码通道被设置，则将数组中索引offset + N的元素放入结果向量的通道索引N，否则将默认元素值放入结果向量的通道索引N。
      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      m - 控制通道选择的掩码
      返回:
      从数组加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于任何掩码被设置的向量通道N，offset+N < 0或offset+N >= a.length

    • fromArray

      public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset)
      从一个double[]类型的数组中收集一个新的向量，使用通过将固定的offset与索引映射中的一系列次要偏移相加而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的连续VLENGTH元素序列。

      对于每个向量通道，其中N是向量通道索引，通道从数组元素a[f(N)]中加载，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。

      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量，如果索引映射中的相对索引补偿以产生数组边界内的值，则可能为负
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      返回:
      从数组的索引元素加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于任何向量中的通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者f(N)=offset+indexMap[mapOffset+N]是a中的无效索引
      参见:

    • fromArray

      public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)
      从一个double[]类型的数组中收集一个新的向量，受掩码控制，并使用通过将固定的offset与索引映射中的一系列次要偏移相加而获得的索引。索引映射是第二个int数组中从给定mapOffset开始的连续VLENGTH元素序列。

      对于每个向量通道，其中N是向量通道索引，如果掩码中设置了通道，则从数组元素a[f(N)]中加载通道，其中f(N)是索引映射表达式offset + indexMap[mapOffset + N]]。结果向量中未设置的通道将设置为零。

      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量，如果索引映射中的相对索引补偿以产生数组边界内的值，则可能为负
      indexMap - 索引映射
      mapOffset - 索引映射中的偏移量
      m - 控制通道选择的掩码
      返回:
      从数组的索引元素加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于任何掩码被设置的向量通道N，mapOffset+N < 0或mapOffset+N >= indexMap.length，或者f(N)=offset+indexMap[mapOffset+N]是a中的无效索引
      参见:

    • fromMemorySegment

      public static DoubleVector fromMemorySegment(VectorSpecies<Double> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      从一个内存段预览中的偏移量开始加载一个向量。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      此方法的行为就好像它返回调用fromMemorySegment()预览的结果如下：

      
 var m = species.maskAll(true);
 return fromMemorySegment(species, ms, offset, bo, m);
      参数:
      species - 所需向量的种类
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      返回:
      从内存段加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于任何向量中的通道N，offset+N*8 < 0或offset+N*8 >= ms.byteSize()
      IllegalArgumentException - 如果内存段是不由byte[]数组支持的堆段。
      IllegalStateException - 如果内存段的会话无效，或者访问来自不是拥有会话的线程的线程。
      自:
      19

    • fromMemorySegment

      public static DoubleVector fromMemorySegment(VectorSpecies<Double> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Double> m)
      从一个内存段预览中的偏移量开始加载一个向量，并使用掩码。掩码未设置的通道将填充double的默认值（正零）。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      以下伪代码说明了行为：

      
 var slice = ms.asSlice(offset);
 double[] ar = new double[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_DOUBLE.withByteAlignment(1), n);
     }
 }
 DoubleVector r = DoubleVector.fromArray(species, ar, 0);
      实现注意:
      如果指定的字节顺序与平台本机顺序相同，则此操作可能更有效，因为此方法不需要重新排序通道值的字节。
      参数:
      species - 所需向量的种类
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      返回:
      从内存段加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于任何掩码被设置的向量通道N，offset+N*8 < 0或offset+N*8 >= ms.byteSize()
      IllegalArgumentException - 如果内存段是不由byte[]数组支持的堆段。
      IllegalStateException - 如果内存段的会话无效，或者访问来自不是拥有会话的线程的线程。
      自:
      19

    • intoArray

      public final void intoArray(double[] a, int offset)
      将此向量存储到一个double[]类型的数组中，从偏移量开始。

      对于每个向量通道，其中N是向量通道索引，将索引N处的通道元素存储到数组元素a[offset+N]中。

      参数:
      a - 数组，类型为double[]
      offset - 数组中的偏移量
      抛出:
      IndexOutOfBoundsException - 如果对于任何向量中的通道N，offset+N < 0或offset+N >= a.length

    • intoArray

      public final void intoArray(double[] a, int offset, VectorMask<Double> m)
      将此向量存储到一个double[]类型的数组中，从偏移量开始并使用掩码。

      对于每个向量通道，其中N是向量通道索引，将索引N处的通道元素存储到数组元素a[offset+N]中。如果N处的掩码通道未设置，则相应的数组元素a[offset+N]保持不变。

      对于掩码被设置的通道进行数组范围检查。未设置掩码的通道不会被存储，也不需要对应于a的合法元素。也就是说，未设置的通道可能对应于小于零或超出数组末尾的数组索引。

      参数:
      a - 数组，类型为 double[]
      offset - 数组中的偏移量
      m - 控制通道存储的掩码
      抛出:
      IndexOutOfBoundsException - 如果对于掩码设置的向量中的任何通道 N，offset+N < 0 或 offset+N >= a.length

    • intoArray

      public final void intoArray(double[] a, int offset, int[] indexMap, int mapOffset)
      将此向量散射到一个类型为 double[] 的数组中，使用通过将固定的 offset 添加到来自 索引映射 的次要偏移量的系列来获得的索引。索引映射是第二个 int 数组中从给定的 mapOffset 开始的连续序列的 VLENGTH 元素。

      对于每个向量通道，其中 N 是向量通道索引，索引为 N 的通道元素存储到数组元素 a[f(N)] 中，其中 f(N) 是索引映射表达式 offset + indexMap[mapOffset + N]]。

      参数:
      a - 数组
      offset - 与索引映射偏移量结合的偏移量
      indexMap - 索引映射
      mapOffset - 索引映射的偏移量
      抛出:
      IndexOutOfBoundsException - 如果 mapOffset+N < 0 或 mapOffset+N >= indexMap.length，或者对于向量中的任何通道 N，f(N)=offset+indexMap[mapOffset+N] 是对数组 a 的无效索引
      参见:

    • intoArray

      public final void intoArray(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)
      将此向量根据掩码散射到一个类型为 double[] 的数组中，使用通过将固定的 offset 添加到来自 索引映射 的次要偏移量的系列来获得的索引。索引映射是第二个 int 数组中从给定的 mapOffset 开始的连续序列的 VLENGTH 元素。

      对于每个向量通道，其中 N 是向量通道索引，如果索引为 N 的掩码通道被设置，则将索引为 N 的通道元素存储到数组元素 a[f(N)] 中，其中 f(N) 是索引映射表达式 offset + indexMap[mapOffset + N]]。

      参数:
      a - 数组
      offset - 与索引映射偏移量结合的偏移量
      indexMap - 索引映射
      mapOffset - 索引映射的偏移量
      m - 掩码
      抛出:
      IndexOutOfBoundsException - 如果 mapOffset+N < 0 或 mapOffset+N >= indexMap.length，或者对于掩码设置的向量中的任何通道 N，f(N)=offset+indexMap[mapOffset+N] 是对数组 a 的无效索引
      参见:

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      将此向量存储到从偏移量开始的 内存段预览，使用显式字节顺序。

      根据指定的字节顺序从原始通道元素中提取字节。通道根据其 内存顺序 存储。

      此方法的行为就好像调用 intoMemorySegment()预览 如下：

      
 var m = maskAll(true);
 intoMemorySegment(ms, offset, bo, m);
      在类中指定:
      intoMemorySegment 在类 Vector<Double>
      参数:
      ms - 内存段
      offset - 进入内存段的偏移量
      bo - 预期的字节顺序
      自:
      19

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Double> m)
      将此向量存储到从偏移量开始的 内存段预览，使用显式字节顺序和掩码。

      根据指定的字节顺序从原始通道元素中提取字节。通道根据其 内存顺序 存储。

      以下伪代码说明了行为，其中 JAVA_E 是原始元素类型的布局，ETYPE 是原始元素类型，EVector 是此向量的原始向量类型：

      
 ETYPE[] a = this.toArray();
 var slice = ms.asSlice(offset)
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         slice.setAtIndex(ValueLayout.JAVA_E.withBitAlignment(8), n);
     }
 }
      在类中指定:
      intoMemorySegment 在类 Vector<Double>
      参数:
      ms - 内存段
      offset - 进入内存段的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      自:
      19

    • reinterpretAsBytes

      public final ByteVector reinterpretAsBytes()
      将此向量视为具有相同形状和内容但通道类型为 byte 的向量，其中字节根据小端顺序从通道中提取。这是一个方便的方法，用于表达式 reinterpretShape(species().withLanes(byte.class))。它可以被视为将字节合并到同一向量中的更大通道的逆操作，例如 Vector.reinterpretAsInts()。
      在类中指定:
      reinterpretAsBytes 在类 Vector<Double>
      返回:
      一个具有相同形状和信息内容的 ByteVector
      参见:

    • viewAsIntegralLanes

      public final LongVector viewAsIntegralLanes()
      将此向量视为具有相同形状、长度和内容但通道类型不是浮点类型的向量。这是对通道值的逐通道重新解释转换。因此，此方法不会更改 VSHAPE 或 VLENGTH，向量的位内容也不会改变。如果向量的 ETYPE 已经是整数类型，则返回相同的向量。此方法返回此表达式的值：convert(conv,0)，其中 conv 是 VectorOperators.Conversion.ofReinterpret(E.class,F.class)，F 是与 E 大小相同的非浮点类型。
      在类中指定:
      viewAsIntegralLanes 在类 Vector<Double>
      返回:
      作为非浮点数重新解释的原始向量
      参见:

    • viewAsFloatingLanes

      public final DoubleVector viewAsFloatingLanes()
      将此向量视为具有相同形状、长度和内容但通道类型为浮点类型的向量。这是对通道值的逐通道重新解释转换。因此，此方法不会更改 VSHAPE 或 VLENGTH，向量的位内容也不会改变。如果向量的 ETYPE 已经是浮点类型，则返回相同的向量。如果向量的元素大小与任何浮点类型大小不匹配，则会抛出 IllegalArgumentException。此方法返回此表达式的值：convert(conv,0)，其中 conv 是 VectorOperators.Conversion.ofReinterpret(E.class,F.class)，F 是与 E 大小相同的浮点类型，如果有的话。
      指定由:
      viewAsFloatingLanes 在类 Vector<Double>
      返回:
      原始向量，重新解释为浮点数
      参见:

    • toString

      public final String toString()
      返回此向量的字符串表示形式，格式为"[0,1,2...]"，报告此向量的车道值，按车道顺序。 生成的字符串就像通过调用Arrays.toString()一样，适用于由this.toArray()返回的double数组。
      指定由:
      toString 在类 Vector<Double>
      返回:
      格式为"[0,1,2...]"的字符串，报告此向量的车道值

    • equals

      public final boolean equals(Object obj)
      指示此向量是否与其他对象相同。 仅当两个向量具有相同的种类和相同的车道值（按相同顺序）时，它们才是相同的。

      车道值的比较就像通过调用Arrays.equals()一样，适用于两个向量上的toArray()返回的数组。

      指定由:
      equals 在类 Vector<Double>
      参数:
      obj - 要比较的参考对象。
      返回:
      此向量是否与其他对象相同
      参见:

    • hashCode

      public final int hashCode()
      返回此向量的哈希码值，基于车道值和向量种类。
      指定由:
      hashCode 在类 Vector<Double>
      返回:
      此向量的哈希码值
      参见:

    • species

      public final VectorSpecies<Double> species()
      从类中复制的描述: Vector
      返回此向量的种类。
      指定由:
      species 在类 Vector<E>
      返回:
      此向量的种类

    • check

      public final <F> Vector<F> check(VectorSpecies<F> species)
      从类中复制的描述: Vector
      检查此向量是否具有给定的种类，并返回此向量不变。 作用类似于此伪代码：species == species() ? this : throw new ClassCastException()。
      指定由:
      check 在类 Vector<E>
      类型参数:
      F - 所需种类的装箱元素类型
      参数:
      species - 所需种类
      返回:
      相同的向量
      参见:

    • check

      public final <F> Vector<F> check(Class<F> elementType)
      检查此向量是否具有给定的元素类型，并返回此向量不变。 作用类似于此伪代码：elementType == species().elementType() ? this : throw new ClassCastException()。
      指定由:
      check 在类 Vector<E>
      类型参数:
      F - 所需车道类型的装箱元素类型
      参数:
      elementType - 所需车道类型
      返回:
      相同的向量
      参见:

    • maskAll

      public final VectorMask<Double> maskAll(boolean bit)
      返回与此向量相同种类的掩码，其中每个车道根据给定的单个布尔值设置或取消设置，该值广播到所有车道。

      此方法返回此表达式的值：species().maskAll(bit)。

      指定由:
      maskAll 在类 Vector<E>
      参数:
      bit - 要复制的给定掩码位
      返回:
      每个车道根据给定位设置或取消设置的掩码
      参见:

    • reinterpretAsShorts

      public ShortVector reinterpretAsShorts()
      将此向量重新解释为具有相同形状和内容但车道类型为short的向量，其中车道根据小端顺序从连续字节组装而成。 这是一个方便的方法，表达式为reinterpretShape(species().withLanes(short.class))。 它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定由:
      reinterpretAsShorts 在类 Vector<E>
      返回:
      具有相同形状和信息内容的ShortVector

    • reinterpretAsInts

      public IntVector reinterpretAsInts()
      将此向量重新解释为具有相同形状和内容但车道类型为int的向量，其中车道根据小端顺序从连续字节组装而成。 这是一个方便的方法，表达式为reinterpretShape(species().withLanes(int.class))。 它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定由:
      reinterpretAsInts 在类 Vector<E>
      返回:
      具有相同形状和信息内容的IntVector

    • reinterpretAsLongs

      public LongVector reinterpretAsLongs()
      将此向量重新解释为具有相同形状和内容但车道类型为long的向量，其中车道根据小端顺序从连续字节组装而成。 这是一个方便的方法，表达式为reinterpretShape(species().withLanes(long.class))。 它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定由:
      reinterpretAsLongs 在类 Vector<E>
      返回:
      具有相同形状和信息内容的LongVector

    • reinterpretAsFloats

      public FloatVector reinterpretAsFloats()
      将此向量重新解释为具有相同形状和内容但车道类型为float的向量，其中车道根据小端顺序从连续字节组装而成。 这是一个方便的方法，表达式为reinterpretShape(species().withLanes(float.class))。 它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定由:
      reinterpretAsFloats 在类 Vector<E>
      返回:
      具有相同形状和信息内容的FloatVector

    • reinterpretAsDoubles

      public DoubleVector reinterpretAsDoubles()
      将此向量重新解释为具有相同形状和内容但车道类型为double的向量，其中车道根据小端顺序从连续字节组装而成。 这是一个方便的方法，表达式为reinterpretShape(species().withLanes(double.class))。 它可以被视为Vector.reinterpretAsBytes()的逆操作。
      指定者：
      reinterpretAsDoubles 在类 Vector<E>
      返回：
      具有相同形状和信息内容的DoubleVector

    • convert

      public final <F> Vector<F> convert(VectorOperators.Conversion<Double,F> conv, int part)
      将此向量转换为具有相同形状和新元素类型的向量，根据指定的转换将当前ETYPE的车道值转换为新的车道类型（此处称为FTYPE）。这是一个逐车道形状不变的操作，它将输入向量中的ETYPE值复制到结果中对应的FTYPE值。根据所选的转换，此操作可能会扩展或收缩其逻辑结果，此时非零的part数可以进一步控制将逻辑结果选择和引导到物理输出向量中。

      每种特定的转换在类VectorOperators中由一个转换常量描述。每个转换操作符都有指定的域类型和范围类型。域类型必须与输入向量的车道类型完全匹配，而范围类型确定输出向量的车道类型。

      转换操作符可以根据其域类型的位大小是相等、小于还是大于其范围类型的位大小，分为就地、扩展或收缩三类。

      独立地，转换操作还可以根据转换是重新解释还是值转换来分类，取决于转换是否保持表示位不变，或者改变表示位以保留（部分或全部）输入值的逻辑值。

      如果重新解释的转换收缩，它将截断输入的高位。如果它扩展，当没有对应的输入位时，它将用零位填充输出的高位。

      像S2I（short值到int）这样的扩展转换会取一个标量值，并以更大的格式表示它（始终带有一些信息冗余）。像D2F（double值到float）这样的收缩转换会取一个标量值，并以较小的格式表示它（始终带有一些信息丢失）。一些就地转换也可能包括信息丢失，例如L2D（long值到double）或F2I（float值到int）。重新解释的就地转换不会丢失信息，除非位值在输出类型中某种方式上不合法。转换NaN的位模式可能会丢弃NaN的尾数位。

      这种分类很重要，因为除非另有说明，转换操作永远不会改变向量形状，无论它们如何改变车道大小。因此，一个扩展转换不能将其所有结果存储在输出向量中，因为输出向量具有更少的更大尺寸的车道，以便具有与输入相同的总位大小。同样，一个收缩转换必须将其相对较小的结果存储到输出向量的一部分车道中，默认情况下未使用的车道填充为零。

      例如，从byte到long的转换（M=8）将丢弃87.5%的输入值，以便将剩余的12.5%转换为宽敞的long车道。逆转换将转换回所有大的结果，但将浪费输出向量中87.5%的车道。就地转换（M=1）将在一个输出向量中提供所有结果，而不浪费车道。

      为了管理这些扩展和收缩的细节，一个非零的part参数选择扩展的部分结果，或将收缩的结果引导到相应的位置，如下所示：

      • 通过M扩展：part必须在范围[0..M-1]内，并选择从原始车道在part*VLENGTH/M处开始的VLENGTH/M输入车道块。

        VLENGTH/M输出车道代表转换的整体逻辑结果的部分切片，填充整个物理输出向量。

      • 通过M收缩：part必须在范围[-M+1..0]内，并将所有VLENGTH输入车道引导到位于原始车道-part*VLENGTH处的输出。总共有VLENGTH*M输出车道，那些不包含转换后的输入值的车道将填充为零。

        一组这样的输出向量，将逻辑结果部分引导到不相交的块中，可以使用按位或或（对于浮点数）FIRST_NONZERO操作符重新组装。

      • 就地（M=1）：part必须为零。两个向量具有相同的VLENGTH。结果始终位于零的原始车道处。

      此方法是更一般但使用频率较低的改变形状方法convertShape()的受限版本。此方法的结果与表达式this.convertShape(conv, rsp, this.broadcast(part))相同，其中输出种类为rsp=this.species().withLanes(FTYPE.class)。

      指定者：
      convert 在类 Vector<E>
      类型参数：
      F - 种类的装箱元素类型
      参数：
      conv - 应用车道方式的所需标量转换
      part - 结果的部分编号，如果既不扩展也不收缩，则为零
      返回：
      通过形状和元素类型从此向量转换的向量
      参见：

    • castShape

      public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)
      将一个向量从一种车道类型转换为另一种，根据需要重新塑造车道大小。此方法返回此表达式的值：convertShape(conv,rsp,part)，其中conv为VectorOperators.Conversion.ofCast(E.class,F.class)。

      如果旧种类和新种类具有不同的形状，则这是一个改变形状操作，可能具有特殊的实现成本。

      指定者：
      castShape 在类 Vector<E>
      类型参数：
      F - 输出种类的装箱元素类型
      参数：
      toSpecies - 所需的输出种类
      part - 结果的部分编号，如果既不扩展也不收缩，则为零
      返回：
      通过元素类型从此向量转换的向量
      参见：

    • convertShape

      public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Double,F> conv, VectorSpecies<F> rsp, int part)
      将此向量转换为给定种类、形状和元素类型的向量，根据指定的转换将当前ETYPE的车道值转换为新的车道类型（此处称为FTYPE）。这是一种逐车道操作，将输入向量中的ETYPE值复制到结果中对应的FTYPE值中。

      如果旧种类和新种类具有相同的形状，则行为与更简单的、形状不变的convert()方法完全相同。在这种情况下，应该使用更简单的方法convert()，以便更容易理解代码。否则，这是一种改变形状的操作，可能具有特殊的实现成本。

      由于形状变化和车道大小变化的综合效果，输入和输出种类可能具有不同的车道计数，导致扩展或收缩。在这种情况下，非零的part参数从扩展的逻辑结果中选择部分结果，或将收缩的逻辑结果的结果导入到所需输出种类的物理输出向量中。

      以下伪代码说明了此方法对于原位、扩展和收缩转换的行为。（此伪代码也适用于形状不变的方法，但对输出种类施加了形状限制。）请注意，对于任何特定的转换运算符和形状组合，只有三个代码路径中的一个与之相关。

      
 FTYPE scalar_conversion_op(ETYPE s);
 EVector a = ...;
 VectorSpecies<F> rsp = ...;
 int part = ...;
 VectorSpecies<E> dsp = a.species();
 int domlen = dsp.length();
 int ranlen = rsp.length();
 FTYPE[] logical = new FTYPE[domlen];
 for (int i = 0; i < domlen; i++) {
   logical[i] = scalar_conversion_op(a.lane(i));
 }
 FTYPE[] physical;
 if (domlen == ranlen) { // 原位
     assert part == 0; //否则AIOOBE
     physical = logical;
 } else if (domlen > ranlen) { // 扩展
     int M = domlen / ranlen;
     assert 0 <= part && part < M; //否则AIOOBE
     int origin = part * ranlen;
     physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // 收缩
     int M = ranlen / domlen;
     assert 0 >= part && part > -M; //否则AIOOBE
     int origin = -part * domlen;
     System.arraycopy(logical, 0, physical, origin, domlen);
 }
 return FVector.fromArray(ran, physical, 0);
      指定者:
      convertShape 在类 Vector<E>
      类型参数:
      F - 输出种类的装箱元素类型
      参数:
      conv - 应用于车道的期望标量转换
      rsp - 期望的输出种类
      part - 结果的部分编号，如果既不扩展也不收缩，则为零
      返回值:
      通过元素类型从此向量转换的向量
      参见:

    • getPayload

      protected final Object getPayload()