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

Class ShortVector

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

  • Field Details

  • Method Details

    • zero

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

    • broadcast

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

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

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

    • broadcast

      public static ShortVector broadcast(VectorSpecies<Short> species, short e)
      返回一个给定种类的向量，其中所有车道元素都设置为原始值e。
      参数:
      species - 所需向量的种类
      e - 要广播的值
      返回:
      一个向量，其中所有车道元素都设置为原始值e
      参见:

    • broadcast

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

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

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

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

    • broadcast

      public static ShortVector broadcast(VectorSpecies<Short> species, long e)
      返回一个给定种类的向量，其中所有车道元素都设置为原始值e。必须准确表示long值，以便ETYPE的向量种类可以表示，使得e==(long)(ETYPE)e。
      参数:
      species - 所需向量的种类
      e - 要广播的值
      返回:
      一个向量，其中所有车道元素都设置为原始值e
      抛出:
      IllegalArgumentException - 如果给定的long值无法被向量的ETYPE表示
      参见:

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • lanewise

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

    • add

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

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

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

    • add

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

    • add

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

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

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

    • add

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

    • sub

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

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

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

    • sub

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

    • sub

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

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

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

    • sub

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

    • mul

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

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

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

    • mul

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

    • mul

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

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

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

    • mul

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

    • div

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

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

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

    • div

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

    • div

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

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

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

    • div

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

    • min

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

    • min

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

    • max

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

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

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

    • max

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

    • and

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

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

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

    • and

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

    • or

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

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

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

    • or

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

    • neg

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

    • abs

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

    • not

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

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

      返回：
      此向量的按位补码~
      另请参见：

    • eq

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

    • eq

      public final VectorMask<Short> eq(short e)
      测试此向量是否等于输入标量。这是一种按通道进行的二进制测试操作，将等于操作（==）应用于每个通道。结果与compare(VectorOperators.Comparison.EQ, e)相同。
      参数：
      e - 输入标量
      返回：
      测试此向量是否等于e的结果掩码
      另请参见：

    • lt

      public final VectorMask<Short> lt(Vector<Short> v)
      测试此向量是否小于另一个输入向量。这是一种按通道进行的二进制测试操作，将小于操作（<）应用于每个通道。结果与compare(VectorOperators.LT, v)相同。
      指定者：
      lt 在类 Vector<Short>
      参数：
      v - 第二个输入向量
      返回：
      测试每个通道是否小于第二个输入向量的掩码结果
      另请参见：

    • lt

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

    • test

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

    • test

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • compare

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

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

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

    • compare

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

    • blend

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

    • addIndex

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

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

      以下伪代码说明了此行为：

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

    • blend

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

    • blend

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

    • slice

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

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

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

    • slice

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

    • unslice

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

    • unslice

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

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

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

    • unslice

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

    • rearrange

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

    • rearrange

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

    • rearrange

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

    • compress

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

    • expand

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

    • selectFrom

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

    • selectFrom

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • bitwiseBlend

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

    • reduceLanes

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

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

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

    • reduceLanes

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

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

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

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

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

    • lane

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

    • withLane

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

    • toArray

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

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

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

    • toIntArray

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

    • toLongArray

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

    • toDoubleArray

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

    • fromArray

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

    • fromArray

      public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)
      从偏移处开始加载类型为short[]的数组的向量，并使用掩码。未设置掩码的通道将填充为short的默认值（零）。对于每个向量通道，其中N是向量通道索引，如果掩码通道位于索引N处被设置，则位于索引offset + N处的数组元素将放入结果向量的通道索引N处，否则将在结果向量的通道索引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 ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset)
      Gathers a new vector composed of elements from an array of type short[], 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 ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)
      Gathers a new vector composed of elements from an array of type short[], 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:

    • fromCharArray

      public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset)
      Loads a vector from an array of type char[] starting at an offset. For each vector lane, where N is the vector lane index, the array element at index offset + N is first cast to a short value and then 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

    • fromCharArray

      public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)
      Loads a vector from an array of type char[] starting at an offset and using a mask. Lanes where the mask is unset are filled with the default value of short (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 first cast to a short value and then placed into the resulting vector at lane index N, otherwise the default element value is placed into the resulting vector at lane index N.
      参数:
      species - 所需向量的种类
      a - 数组
      offset - 数组中的偏移量
      m - 控制通道选择的掩码
      返回:
      从数组加载的向量
      抛出:
      IndexOutOfBoundsException - 如果对于向量中设置了掩码的任何通道 N，offset+N < 0 或 offset+N >= a.length

    • fromCharArray

      public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset)
      收集一个由类型为 char[] 的数组中的元素组成的新向量，使用通过将固定的 offset 添加到来自索引映射的一系列次要偏移量而获得的索引。索引映射是第二个 int 数组中从给定的 mapOffset 开始的连续序列的 VLENGTH 元素。

      对于每个向量通道，其中 N 是向量通道索引，通道从表达式 (short) 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
      参见:

    • fromCharArray

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

      对于每个向量通道，其中 N 是向量通道索引，如果掩码中设置了通道，则从表达式 (short) 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 ShortVector fromMemorySegment(VectorSpecies<Short> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
      从 内存段预览 开始的偏移量加载一个向量。字节根据指定的字节顺序组成原始通道元素。向量根据内存排序排列。

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

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

    • fromMemorySegment

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

      以下伪代码说明了行为：

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

    • intoArray

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

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

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

    • intoArray

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

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

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

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

    • intoArray

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

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

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

    • intoArray

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

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

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

    • intoCharArray

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

      对于每个向量通道，其中N是向量通道索引，将索引为N的通道元素首先转换为char值，然后存储到数组元素a[offset+N]中。

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

    • intoCharArray

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

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

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

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

    • intoCharArray

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

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

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

    • intoCharArray

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

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

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

    • intoMemorySegment

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

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

      此方法的行为就像调用intoMemorySegment()预览一样，如下所示：

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

    • intoMemorySegment

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

    • reinterpretAsBytes

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

    • viewAsIntegralLanes

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

    • viewAsFloatingLanes

      public final Vector<?> viewAsFloatingLanes()
      将此向量视为具有相同形状、长度和内容但车道类型为浮点类型的向量。这是对车道值进行的逐车道重新解释转换。因此，此方法不会更改VSHAPE或VLENGTH，向量的位内容也不会更改。如果向量的ETYPE已经是浮点类型，则返回相同的向量。如果向量的元素大小与任何浮点类型大小不匹配，则会抛出IllegalArgumentException。此方法返回此表达式的值：convert(conv,0)，其中conv是VectorOperators.Conversion.ofReinterpret(E.class,F.class)，而F是与E大小相同的浮点类型（如果有的话）。
      指定者:
      viewAsFloatingLanes 在类 Vector<Short>中
      实现注意:
      此方法始终抛出UnsupportedOperationException，因为没有与short大小相同的浮点类型。此方法的返回类型被任意指定为Vector<?>。如果将来的API版本中提供了其他浮点类型，则可能会更改返回类型。
      返回:
      重新解释为浮点数的原始向量
      另请参阅:

    • toString

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

    • equals

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

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

      指定者:
      equals 在类 Vector<Short>中
      参数:
      obj - 用于比较的参考对象
      返回:
      此向量是否与其他对象相同
      另请参阅:

    • hashCode

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

    • species

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    • castShape

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

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

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

    • convertShape

      public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Short,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()