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

Class LongVector

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

  • Field Details

  • Method Details

    • zero

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

    • broadcast

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

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

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

    • broadcast

      public static LongVector broadcast(VectorSpecies<Long> species, long e)
      返回与给定种类相同的向量，其中所有通道元素均设置为原始值e。
      参数：
      species - 所需向量的种类
      e - 要广播的值
      返回：
      所有通道元素均设置为原始值e的向量
      参见：

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

      public final LongVector lanewise(VectorOperators.Binary op, long e)
      将此向量的lane值与广播标量的值组合。这是一种lane-wise二元操作，将所选操作应用于每个lane。返回值将等于此表达式：this.lanewise(op, this.broadcast(e))。
      指定者:
      lanewise 在类 Vector<Long>
      参数:
      op - 用于处理lane值的操作
      e - 输入标量
      返回值:
      将操作应用于两个输入向量的每个lane后的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • add

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

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

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

    • add

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

    • add

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

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

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

    • add

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

    • sub

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

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

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

    • sub

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

    • sub

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

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

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

    • sub

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

    • mul

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

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

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

    • mul

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

    • mul

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

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

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

    • mul

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

    • div

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

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

      指定者:
      div 在类 Vector<Long>
      API 注意:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      v - 第二个输入向量
      返回:
      将此向量除以第二个输入向量的结果
      参见:

    • div

      public final LongVector div(long e)
      将此向量除以输入标量的广播。这是一种逐个通道的二进制操作，对每个通道应用原始除法操作（/）。此方法也等同于表达式lanewise(DIV, e)。
      API 注意:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      返回:
      将此向量的每个通道除以标量的结果
      参见:

    • div

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

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

      指定者:
      div 在类 Vector<Long>
      API 注意:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      v - 第二个输入向量
      m - 控制通道选择的掩码
      返回:
      将此向量除以第二个输入向量的结果
      参见:

    • div

      public final LongVector div(long e, VectorMask<Long> m)
      将此向量除以输入标量的广播，选择由掩码控制的通道元素。这是一种受掩码控制的逐个通道的二进制操作，对每个通道应用原始除法操作（/）。此方法也等同于表达式lanewise(DIV, s, m)。
      API 注意:
      如果存在零除数，将抛出 ArithmeticException。
      参数:
      e - 输入标量
      m - 控制通道选择的掩码
      返回:
      将此向量的每个通道除以标量的结果
      参见:

    • min

      public final LongVector min(Vector<Long> v)
      计算此向量和第二个输入向量中较小的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.min()。此方法也等效于表达式lanewise(MIN, v)。
      指定者:
      min 在类 Vector<Long>
      参数:
      v - 第二个输入向量
      返回:
      此向量和第二个输入向量的逐个通道最小值
      参见:

    • min

      public final LongVector min(long e)
      计算此向量和输入标量的广播中较小的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.min()。此方法也等效于表达式lanewise(MIN, e)。
      参数:
      e - 输入标量
      返回:
      将此向量乘以给定标量的结果
      参见:

    • max

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

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

      指定者:
      max 在类 Vector<Long>
      参数:
      v - 第二个输入向量
      返回:
      此向量和第二个输入向量的逐个通道最大值
      参见:

    • max

      public final LongVector max(long e)
      计算此向量和输入标量的广播中较大的值。这是一种逐个通道的二进制操作，对每对对应通道值应用操作Math.max()。此方法也等效于表达式lanewise(MAX, e)。
      参数:
      e - 输入标量
      返回:
      将此向量乘以给定标量的结果
      参见:

    • and

      public final LongVector and(Vector<Long> v)
      计算此向量和第二个输入向量的按位逻辑与（&）。这是一种逐个通道的二进制操作，对每对对应通道值应用原始按位"与"操作（&）。此方法也等效于表达式lanewise(AND, v)。

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

      参数:
      v - 第二个输入向量
      返回:
      此向量和第二个输入向量的按位&
      参见:

    • and

      public final LongVector and(long e)
      计算此向量和标量的按位逻辑与（&）。这是一种逐个通道的二进制操作，对每对对应通道值应用原始按位"与"操作（&）。此方法也等效于表达式lanewise(AND, e)。
      参数:
      e - 输入标量
      返回:
      此向量和标量的按位&
      参见:

    • or

      public final LongVector or(Vector<Long> v)
      计算此向量和第二个输入向量的按位逻辑或（|）。这是一种逐个通道的二进制操作，对每对对应通道值应用原始按位"或"操作（|）。此方法也等效于表达式lanewise(AND, v)。

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

      参数:
      v - 第二个输入向量
      返回:
      此向量和第二个输入向量的按位|
      参见:

    • or

      public final LongVector or(long e)
      计算此向量和标量的按位逻辑或（|）。这是一种逐个通道的二进制操作，对每对对应通道值应用原始按位"或"操作（|）。此方法也等效于表达式lanewise(OR, e)。
      参数:
      e - 输入标量
      返回:
      此向量和标量的按位|
      参见:

    • neg

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

    • abs

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

    • not

      public final LongVector not()
      计算这个向量的按位逻辑补码（~）。这是一个按通道的二元操作，对每个通道值应用原始的按位“非”操作（~）。这个方法也等同于表达式lanewise(NOT)。

      这不是一个完整的命名操作，类似于add。这个操作的掩码版本不是直接可用的，但可以通过lanewise的掩码版本获得。

      返回值:
      这个向量的按位补码~
      参见:

    • eq

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

    • eq

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

    • lt

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

    • lt

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

    • test

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

    • test

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

    • compare

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

    • compare

      public abstract VectorMask<Long> compare(VectorOperators.Comparison op, long e)
      Tests this vector by comparing it with an input scalar, according to the given comparison operation. This is a lane-wise binary test operation which applies the comparison operation to each lane.

      The result is the same as compare(op, broadcast(species(), e)). That is, the scalar may be regarded as broadcast to a vector of the same species, and then compared against the original vector, using the selected comparison operation.

      Specified by:
      compare in class Vector<Long>
      Parameters:
      op - the operation used to compare lane values
      e - the input scalar
      Returns:
      the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator
      See Also:

    • compare

      public final VectorMask<Long> compare(VectorOperators.Comparison op, long e, VectorMask<Long> m)
      Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask. This is a masked lane-wise binary test operation which applies to each pair of corresponding lane values. The returned result is equal to the expression compare(op,s).and(m).
      Specified by:
      compare in class Vector<Long>
      Parameters:
      op - the operation used to compare lane values
      e - the input scalar
      m - the mask controlling lane selection
      Returns:
      the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator, and only in the lanes selected by the mask
      See Also:

    • blend

      public abstract LongVector blend(Vector<Long> v, VectorMask<Long> m)
      Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask. This is a masked lane-wise binary operation which selects each lane value from one or the other input.
      • For any lane set in the mask, the new lane value is taken from the second input vector, and replaces whatever value was in the that lane of this vector.
      • For any lane unset in the mask, the replacement is suppressed and this vector retains the original value stored in that lane.
      The following pseudocode illustrates this behavior: 
      
 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);
      Specified by:
      blend in class Vector<Long>
      Parameters:
      v - the second input vector, containing replacement lane values
      m - the mask controlling lane selection from the second input vector
      Returns:
      the result of blending the lane elements of this vector with those of the second input vector

    • addIndex

      public abstract LongVector addIndex(int scale)
      Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant. This is a lane-wise unary operation which, for each lane N, computes the scaled index value N*scale and adds it to the value already in lane N of the current vector.

      The scale must not be so large, and the element size must not be so small, that that there would be an overflow when computing any of the N*scale or VLENGTH*scale, when the result is represented using the vector lane type ETYPE.

      The following pseudocode illustrates this behavior:

      
 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);
      Specified by:
      addIndex in class Vector<Long>
      Parameters:
      scale - the number to multiply by each lane index N, typically 1
      Returns:
      the result of incrementing each lane element by its corresponding lane index N, scaled by scale

    • blend

      public final LongVector blend(long e, VectorMask<Long> m)
      Replaces selected lanes of this vector with a scalar value under the control of a mask. This is a masked lane-wise binary operation which selects each lane value from one or the other input. The returned result is equal to the expression blend(broadcast(e),m).
      Specified by:
      blend in class Vector<Long>
      Parameters:
      e - the input scalar, containing the replacement lane value
      m - the mask controlling lane selection of the scalar
      Returns:
      the result of blending the lane elements of this vector with the scalar value

    • slice

      public abstract LongVector slice(int origin, Vector<Long> v1)
      Slices a segment of adjacent lanes, starting at a given origin lane in the current vector, and continuing (as needed) into an immediately following vector. The block of VLENGTH lanes is extracted into its own vector and returned.

      This is a cross-lane operation that shifts lane elements to the front, from the current vector and the second vector. Both vectors can be viewed as a combined "background" of length 2*VLENGTH, from which a slice is extracted. The lane numbered N in the output vector is copied from lane origin+N of the input vector, if that lane exists, else from lane origin+N-VLENGTH of the second vector (which is guaranteed to exist).

      The origin value must be in the inclusive range 0..VLENGTH. As limiting cases, v.slice(0,w) and v.slice(VLENGTH,w) return v and w, respectively.

      Parameters:
      origin - the first input lane to transfer into the slice
      v1 - a second vector logically concatenated with the first, before the slice is taken (if omitted it defaults to zero)
      Returns:
      a contiguous slice of VLENGTH lanes, taken from this vector starting at the indicated origin, and continuing (as needed) into the second vector
      See Also:

    • slice

      public final LongVector slice(int origin, Vector<Long> w, VectorMask<Long> m)
      Slices a segment of adjacent lanes under the control of a mask, starting at a given origin lane in the current vector, and continuing (as needed) into an immediately following vector. The block of VLENGTH lanes is extracted into its own vector and returned. The resulting vector will be zero in all lanes unset in the given mask. Lanes set in the mask will contain data copied from selected lanes of this or v1.

      This is a cross-lane operation that shifts lane elements to the front, from the current vector and the second vector. Both vectors can be viewed as a combined "background" of length 2*VLENGTH, from which a slice is extracted. The returned result is equal to the expression broadcast(0).blend(slice(origin,v1),m).

      Specified by:
      slice in class Vector<Long>
      Parameters:
      origin - the first input lane to transfer into the slice
      w - a second vector logically concatenated with the first, before the slice is taken (if omitted it defaults to zero)
      m - the mask controlling lane selection into the resulting vector
      Returns:
      a contiguous slice of VLENGTH lanes, taken from this vector starting at the indicated origin, and continuing (as needed) into the second vector
      See Also:

    • slice

      public abstract LongVector slice(int origin)
      从当前向量中的给定origin车道开始，切割相邻车道的片段。一块由VLENGTH车道组成的块，可能会用零车道填充，被提取到自己的向量中并返回。这是一个方便的方法，它从一个单一向量中切片，背景是零车道的扩展。它等同于slice (origin, broadcast(0))。它也可以简单地被视为从后面的车道向前的跨车道移位，用零填充在向量末尾的空车道。在这个视图中，移位计数是origin。
      参数:
      origin - 要传输到切片中的第一个输入车道
      返回:
      最后的VLENGTH-origin个输入车道，从输出的第一个车道开始放置，末尾用零填充
      参见:

    • unslice

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

    • unslice

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

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

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

    • unslice

      public abstract LongVector unslice(int origin)
      反转一个slice()，将当前向量作为一个切片插入到一个值为零的“背景”输入中。与其他unslice()方法相比，此方法只返回背景向量对中的第一个。这是一个方便的方法，它返回以下伪代码的结果： 

      
 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);
      指定者:
      unslice 在类 Vector<Long>
      参数:
      origin - 接收切片的第一个输出车道
      返回:
      第一个VLENGTH-origin个输入车道，从给定的起始位置开始放置，开头用零填充
      参见:

    • rearrange

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

    • rearrange

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

    • rearrange

      public abstract LongVector rearrange(VectorShuffle<Long> s, Vector<Long> 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<Long>
      参数：
      s - 控制从两个输入向量中选择车道的洗牌
      v - 第二个输入向量
      返回：
      这个向量和第二个输入向量的车道元素的重新排列
      参见：

    • compress

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

    • expand

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

    • selectFrom

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

    • selectFrom

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

    • bitwiseBlend

      public final LongVector bitwiseBlend(Vector<Long> bits, Vector<Long> mask)
      在第三个向量的控制下，将两个向量的位混合在一起，该向量提供掩码位。这是一个车道级三元操作，对每个车道执行位混合操作(a&~c)|(b&c)。此方法也等同于表达式lanewise(BITWISE_BLEND, bits, mask)。
      参数：
      bits - 要混合到当前向量中的输入位
      mask - 位掩码，用于启用输入位的混合
      返回：
      将给定位混合到当前向量中的位，受位掩码控制
      参见：

    • bitwiseBlend

      public final LongVector bitwiseBlend(long bits, long mask)
      在另一个标量的控制下，将一个向量和一个标量的位混合在一起，该标量提供掩码位。这是一个车道级三元操作，对每个车道执行位混合操作(a&~c)|(b&c)。此方法也等同于表达式lanewise(BITWISE_BLEND, bits, mask)。
      参数：
      bits - 要混合到当前向量中的输入位
      mask - 位掩码，用于启用输入位的混合
      返回：
      将给定位混合到当前向量中的位，受位掩码控制
      参见：

    • bitwiseBlend

      public final LongVector bitwiseBlend(long bits, Vector<Long> mask)
      在另一个向量的控制下，将一个向量和一个标量的位混合在一起，该向量提供掩码位。这是一个车道级三元操作，对每个车道执行位混合操作(a&~c)|(b&c)。此方法也等同于表达式lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 用于启用输入位混合的位掩码
      返回:
      给定位的按位混合结果，受位掩码控制
      参见:

    • bitwiseBlend

      public final LongVector bitwiseBlend(Vector<Long> bits, long mask)
      在标量的控制下混合两个向量的位，标量提供掩码位。这是一个按通道进行的三元操作，对每个通道执行按位混合操作(a&~c)|(b&c)。该方法也等同于表达式lanewise(BITWISE_BLEND, bits, mask)。
      参数:
      bits - 要混合到当前向量中的输入位
      mask - 用于启用输入位混合的位掩码
      返回:
      给定位的按位混合结果，受位掩码控制
      参见:

    • reduceLanes

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

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

      • 对于FIRST_NONZERO的情况，归约将返回从编号最低的非零通道中获取的值。
      • 所有其他归约操作都是完全可交换和可结合的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合通道值的操作
      返回:
      累积的结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • reduceLanes

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

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

      • 如果操作是ADD、XOR、OR或FIRST_NONZERO，则标识值为零，默认的long值。
      • 如果操作是MUL，则标识值为一。
      • 如果操作是AND，则标识值为负一（所有位设置）。
      • 如果操作是MAX，则标识值为Long.MIN_VALUE。
      • 如果操作是MIN，则标识值为Long.MAX_VALUE。

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

      • 对于FIRST_NONZERO的情况，归约将返回从编号最低的非零通道中获取的值。
      • 所有其他归约操作都是完全可交换和可结合的。实现可以选择任何处理顺序，但它将始终产生相同的结果。
      参数:
      op - 用于组合通道值的操作
      m - 控制通道选择的掩码
      返回:
      从选定通道值累积的归约结果
      抛出:
      UnsupportedOperationException - 如果此向量不支持请求的操作
      参见:

    • lane

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

    • withLane

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

    • toArray

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

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

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

    • toIntArray

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

    • toLongArray

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

    • toDoubleArray

      public final double[] toDoubleArray()
      返回一个包含所有通道值的double[]数组，转换为类型double。数组长度与向量长度相同。数组元素按照强制转换的方式转换并按通道顺序存储。如果向量元素类型为long，此操作可能会丢失精度。
      指定者：
      toDoubleArray 在类 Vector<Long>中
      实现注意：
      当在LongVector类型的向量上使用此方法时，对于大幅度的通道值，可能会丢失长达九位的精度。
      返回：
      包含此向量的通道值的double[]数组，可能四舍五入以表示可表示的double值
      另请参见：

    • fromArray

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

    • fromArray

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

    • fromArray

      public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset)
      从long[]类型的数组中收集由索引映射的次要偏移量加上固定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中的无效索引，对于向量中的任何通道N

    • fromArray

      public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)
      从long[]类型的数组中收集由掩码控制的元素组成的新向量，使用索引映射的次要偏移量加上固定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中的无效索引，对于设置了掩码的任何通道N

    • fromMemorySegment

      public static LongVector fromMemorySegment(VectorSpecies<Long> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      从内存段的偏移处开始加载long[]类型的数组中的向量。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      此方法的行为就好像返回调用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 LongVector fromMemorySegment(VectorSpecies<Long> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Long> m)
      从内存段的偏移处开始加载long[]类型的数组中的向量，并使用掩码。未设置掩码的通道将填充默认值long（零）。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

      以下伪代码说明了行为：

      
 var slice = ms.asSlice(offset);
 long[] ar = new long[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_LONG.withByteAlignment(1), n);
     }
 }
 LongVector r = LongVector.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(long[] a, int offset)
      将此向量存储到从偏移量开始的long[]类型的数组中。

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

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

    • intoArray

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

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

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

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

    • intoArray

      public final void intoArray(long[] a, int offset, int[] indexMap, int mapOffset)
      将此向量散射到long[]类型的数组中，使用通过从索引映射的一系列次要偏移量添加到固定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中的无效索引，对于向量中的任何通道N
      参见：

    • intoArray

      public final void intoArray(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)
      将此向量散射到long[]类型的数组中，在掩码的控制下，并使用通过从索引映射的一系列次要偏移量添加到固定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中的无效索引，对于向量中设置了掩码的任何通道N
      参见：

    • intoMemorySegment

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

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

      此方法的行为就好像调用intoMemorySegment(ms, offset, bo, m)如下：

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

    • intoMemorySegment

      public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Long> 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<Long>中
      参数：
      ms - 内存段
      offset - 内存段中的偏移量
      bo - 预期的字节顺序
      m - 控制通道选择的掩码
      自：
      19

    • reinterpretAsBytes

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

    • viewAsIntegralLanes

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

    • viewAsFloatingLanes

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

    • toString

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

    • equals

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

      车道值的比较方式类似于调用Arrays.equals()，适用于两个向量上的toArray()返回的数组。

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

    • hashCode

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

    • species

      public final VectorSpecies<Long> 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<Long> 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<Long,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]内，并选择从原始通道开始的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<Long,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) { // in-place
     assert part == 0; //else AIOOBE
     physical = logical;
 } else if (domlen > ranlen) { // expanding
     int M = domlen / ranlen;
     assert 0 <= part && part < M; //else AIOOBE
     int origin = part * ranlen;
     physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // contracting
     int M = ranlen / domlen;
     assert 0 >= part && part > -M; //else 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()