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

Class FloatVector

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

  • Field Details

  • Method Details

    • zero

      public static FloatVector zero(VectorSpecies<Float> species)
      返回所有lane元素均设置为零的给定species的向量，即默认的原始值。
      参数:
      species - 所需零向量的species
      返回:
      一个零向量

    • broadcast

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

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

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

    • broadcast

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

    • broadcast

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

    • broadcast

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • add

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

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

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

    • add

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

    • add

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

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

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

    • add

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

    • sub

      public final FloatVector sub(Vector<Float> v)
      从此向量中减去第二个输入向量。这是一种通道级二元操作，将原始减法操作（-）应用于每对对应通道值。此方法也等同于表达式lanewise(SUB, v)。

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

      指定者:
      sub 在类 Vector<Float>
      参数:
      v - 第二个输入向量
      返回:
      将第二个输入向量从此向量中减去的结果
      参见:

    • sub

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

    • sub

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

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

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

    • sub

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

    • mul

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

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

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

    • mul

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

    • mul

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

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

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

    • mul

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

    • div

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

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

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

    • div

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

    • div

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

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

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

    • div

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

    • min

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

    • min

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

    • max

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

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

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

    • max

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

    • pow

      public final FloatVector pow(Vector<Float> b)
      将此向量的每个元素提升为第二个输入向量的幂。这是一种逐个元素的二元操作，对每对对应的元素应用符合规范Math.pow(a,b)的操作。该操作被调整为将操作数和结果转换，具体地将float操作数扩展为double操作数，并将double结果缩小为float结果。此方法也等同于表达式lanewise(POW, b)。

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

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

    • pow

      public final FloatVector pow(float b)
      将此向量提升为标量幂。这是一种逐个元素的二元操作，对每对对应的元素应用符合规范Math.pow(a,b)的操作。该操作被调整为将操作数和结果转换，具体地将float操作数扩展为double操作数，并将double结果缩小为float结果。此方法也等同于表达式lanewise(POW, b)。
      参数:
      b - 用于提升此向量的标量指数
      返回值:
      此向量的b次幂
      参见:

    • neg

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

    • abs

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

    • sqrt

      public final FloatVector sqrt()
      计算此向量的平方根。这是一种逐个元素的一元操作，对每个元素应用符合规范Math.sqrt(a)的操作。该操作被调整为将操作数和结果转换，具体地将float操作数扩展为double操作数，并将double结果缩小为float结果。此方法也等同于表达式lanewise(SQRT)。
      返回值:
      此向量的平方根
      参见:

    • eq

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

    • eq

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

    • lt

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

    • lt

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

    • test

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

    • test

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • blend

      public abstract FloatVector blend(Vector<Float> v, VectorMask<Float> 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<Float>
      参数：
      v - 第二个输入向量，包含替换通道值
      m - 控制从第二个输入向量选择通道的掩码
      返回：
      将此向量的通道元素与第二个输入向量的通道元素混合的结果

    • addIndex

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

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

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

      
 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<Float>
      参数：
      scale - 乘以每个通道索引N的数字，通常为1
      返回：
      将每个通道元素递增其对应的通道索引N，乘以scale的结果

    • blend

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

    • blend

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

    • slice

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

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

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

    • slice

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

    • unslice

      public abstract FloatVector unslice(int origin, Vector<Float> 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<Float>
      参数：
      origin - 接收切片的第一个输出通道
      w - 将接收插入切片的“背景”向量（作为两个副本）
      part - 结果的部分编号（零或一）
      返回：
      两个背景向量对中的第一个或第二个部分w，通过在指定的起始位置插入此向量进行更新
      参见：

    • unslice

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

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

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

    • unslice

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

    • rearrange

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

    • rearrange

      public abstract FloatVector rearrange(VectorShuffle<Float> s, VectorMask<Float> 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<Float>
      参数：
      s - 控制通道索引选择的洗牌
      m - 控制洗牌应用的掩码
      返回：
      重新排列此向量的通道元素
      参见：

    • rearrange

      public abstract FloatVector rearrange(VectorShuffle<Float> s, Vector<Float> 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<Float>中
      参数:
      s - 控制来自两个输入向量的通道选择的洗牌
      v - 第二个输入向量
      返回:
      对该向量和第二个输入向量的通道元素重新排列
      参见:

    • compress

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

    • expand

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

    • selectFrom

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

    • selectFrom

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

    • fma

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

    • fma

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

    • reduceLanes

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

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

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

    • reduceLanes

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

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

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

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

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

    • lane

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

    • withLane

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

    • toArray

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

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

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

    • toIntArray

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

    • toLongArray

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

    • toDoubleArray

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

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset)
      Loads a vector from an array of type float[] starting at an offset. For each vector lane, where N is the vector lane index, the array element at index offset + N is placed into the resulting vector at lane index N.
      Parameters:
      species - species of desired vector
      a - the array
      offset - the offset into the array
      Returns:
      the vector loaded from an array
      Throws:
      IndexOutOfBoundsException - if offset+N < 0 or offset+N >= a.length for any lane N in the vector

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)
      Loads a vector from an array of type float[] starting at an offset and using a mask. Lanes where the mask is unset are filled with the default value of float (positive zero). For each vector lane, where N is the vector lane index, if the mask lane at index N is set then the array element at index offset + N is placed into the resulting vector at lane index N, otherwise the default element value is placed into the resulting vector at lane index N.
      Parameters:
      species - species of desired vector
      a - the array
      offset - the offset into the array
      m - the mask controlling lane selection
      Returns:
      the vector loaded from an array
      Throws:
      IndexOutOfBoundsException - if offset+N < 0 or offset+N >= a.length for any lane N in the vector where the mask is set

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)
      Gathers a new vector composed of elements from an array of type float[], using indexes obtained by adding a fixed offset to a series of secondary offsets from an index map. The index map is a contiguous sequence of VLENGTH elements in a second array of ints, starting at a given mapOffset.

      For each vector lane, where N is the vector lane index, the lane is loaded from the array element a[f(N)], where f(N) is the index mapping expression offset + indexMap[mapOffset + N]].

      Parameters:
      species - species of desired vector
      a - the array
      offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
      indexMap - the index map
      mapOffset - the offset into the index map
      Returns:
      the vector loaded from the indexed elements of the array
      Throws:
      IndexOutOfBoundsException - if mapOffset+N < 0 or if mapOffset+N >= indexMap.length, or if f(N)=offset+indexMap[mapOffset+N] is an invalid index into a, for any lane N in the vector
      See Also:

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
      Gathers a new vector composed of elements from an array of type float[], under the control of a mask, and using indexes obtained by adding a fixed offset to a series of secondary offsets from an index map. The index map is a contiguous sequence of VLENGTH elements in a second array of ints, starting at a given mapOffset.

      For each vector lane, where N is the vector lane index, if the lane is set in the mask, the lane is loaded from the array element a[f(N)], where f(N) is the index mapping expression offset + indexMap[mapOffset + N]]. Unset lanes in the resulting vector are set to zero.

      Parameters:
      species - species of desired vector
      a - the array
      offset - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
      indexMap - the index map
      mapOffset - the offset into the index map
      m - the mask controlling lane selection
      Returns:
      the vector loaded from the indexed elements of the array
      Throws:
      IndexOutOfBoundsException - if mapOffset+N < 0 or if mapOffset+N >= indexMap.length, or if f(N)=offset+indexMap[mapOffset+N] is an invalid index into a, for any lane N in the vector where the mask is set
      See Also:

    • fromMemorySegment

      public static FloatVector fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment. Bytes are composed into primitive lane elements according to the specified byte order. The vector is arranged into lanes according to memory ordering.

      This method behaves as if it returns the result of calling fromMemorySegment()PREVIEW as follows:

      
 var m = species.maskAll(true);
 return fromMemorySegment(species, ms, offset, bo, m);
      Parameters:
      species - species of desired vector
      ms - the memory segment
      offset - the offset into the memory segment
      bo - the intended byte order
      Returns:
      a vector loaded from the memory segment
      Throws:
      IndexOutOfBoundsException - if offset+N*4 < 0 or offset+N*4 >= ms.byteSize() for any lane N in the vector
      IllegalArgumentException - if the memory segment is a heap segment that is not backed by a byte[] array.
      IllegalStateException - if the memory segment's session is not alive, or if access occurs from a thread other than the thread owning the session.
      Since:
      19

    • fromMemorySegment

      public static FloatVector fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Float> m)
      Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask. Lanes where the mask is unset are filled with the default value of float (positive zero). Bytes are composed into primitive lane elements according to the specified byte order. The vector is arranged into lanes according to memory ordering.

      The following pseudocode illustrates the behavior:

      
 var slice = ms.asSlice(offset);
 float[] ar = new float[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_FLOAT.withByteAlignment(1), n);
     }
 }
 FloatVector r = FloatVector.fromArray(species, ar, 0);
      Implementation Note:
      This operation is likely to be more efficient if the specified byte order is the same as the platform native order, since this method will not need to reorder the bytes of lane values.
      Parameters:
      species - species of desired vector
      ms - the memory segment
      offset - the offset into the memory segment
      bo - the intended byte order
      m - the mask controlling lane selection
      Returns:
      a vector loaded from the memory segment
      Throws:
      IndexOutOfBoundsException - if offset+N*4 < 0 or offset+N*4 >= ms.byteSize() for any lane N in the vector where the mask is set
      IllegalArgumentException - if the memory segment is a heap segment that is not backed by a byte[] array.
      IllegalStateException - if the memory segment's session is not alive, or if access occurs from a thread other than the thread owning the session.
      Since:
      19

    • intoArray

      public final void intoArray(float[] a, int offset)
      Stores this vector into an array of type float[] starting at an offset.

      For each vector lane, where N is the vector lane index, the lane element at index N is stored into the array element a[offset+N].

      Parameters:
      a - the array, of type float[]
      offset - the offset into the array
      Throws:
      IndexOutOfBoundsException - if offset+N < 0 or offset+N >= a.length for any lane N in the vector

    • intoArray

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

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

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

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

    • intoArray

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

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

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

    • intoArray

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

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

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

    • intoMemorySegment

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

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

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

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

    • intoMemorySegment

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

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

      以下伪代码说明了行为，其中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<Float>
      参数:
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      自:
      19

    • reinterpretAsBytes

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

    • viewAsIntegralLanes

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

    • viewAsFloatingLanes

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

    • toString

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

    • equals

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

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

      指定者：
      equals 在类中 Vector<Float>
      参数：
      obj - 要比较的参考对象。
      返回：
      此向量是否与其他某个对象相同
      参见：

    • hashCode

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

    • species

      public final VectorSpecies<Float> 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<Float> 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<Float,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))相同，其中输出species为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<Float,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()