java.lang.Object

jdk.incubator.vector.VectorMask<E>

类型参数：: E - ETYPE 的盒装版本，向量的元素类型
基于值的类和身份操作
VectorMask 和 Vector 是一个 value-based 类。使用 VectorMask 时，诸如 == 之类的身份敏感操作可能会产生不可预知的结果，或降低性能。奇怪的是，v.equals(w) 可能比 v==w 更快，因为 equals 是 not 身份敏感方法。（toString 和 hashCode 都不是。）此外，矢量掩码对象可以存储在局部变量和参数中以及作为 static final 常量，但将它们存储在其他 Java 字段或数组元素中，虽然在语义上有效，但可能会导致性能下降。

public abstract class VectorMask<E> extends Object

VectorMask 表示 boolean 值的有序不可变序列。

同一个元素类型（ETYPE）和shape 的VectorMask和Vector具有相同的通道数，因此是兼容的（具体来说，它们的vector species 是兼容的）。

一些向量操作接受（兼容的）掩码来控制输入向量的车道元素的选择和操作。

序列中值的数量称为 VectorMask length 。长度也对应于 VectorMask 通道的数量。车道索引 N 处的车道元素（从 0 开始，包括在内，到长度，不包括在内）对应于序列中的第 N + 1 个值。

如果泳道元素为 true ，则称泳道为 set ；否则，如果泳道元素为 false ，则称泳道为 unset 。

VectorMask 声明了一组有限的一元、二元和归约运算。

车道一元运算对一个输入掩码进行操作并产生结果掩码。对于输入掩码的每个通道，使用指定的标量一元运算对通道元素进行运算，并将布尔结果放入同一通道的掩码结果中。以下伪代码说明了此操作类别的行为：
```
 VectorMask<E> a = ...;
 boolean[] ar = new boolean[a.length()];
 for (int i = 0; i < a.length(); i++) {
   ar[i] = scalar_unary_op(a.laneIsSet(i));
 }
 VectorMask<E> r = VectorMask.fromArray(a.vectorSpecies(), ar, 0);
  
```
车道二元运算对两个输入掩码进行运算以生成结果掩码。对于两个输入掩码 a 和 b 的每个通道，使用指定的标量二元运算对来自 a 和 b 的相应通道元素进行运算，并将布尔结果放入同一通道的掩码结果中。以下伪代码说明了此操作类别的行为：
```
 VectorMask<E> a = ...;
 VectorMask<E> b = ...;
 boolean[] ar = new boolean[a.length()];
 for (int i = 0; i < a.length(); i++) {
   ar[i] = scalar_binary_op(a.laneIsSet(i), b.laneIsSet(i));
 }
 VectorMask<E> r = VectorMask.fromArray(a.vectorSpecies(), ar, 0);
  
```
跨车道缩减操作接受输入掩码并产生标量结果。对于输入掩码的每个通道，使用指定的标量二元运算对通道元素以及标量累加值进行运算。标量结果是累加器的最终值。以下伪代码说明了此操作类别的行为：
```
 Mask<E> a = ...;
 int acc = zero_for_scalar_binary_op; // 0, or 1 for &
 for (int i = 0; i < a.length(); i++) {
   acc = scalar_binary_op(acc, a.laneIsSet(i) ? 1 : 0); // & | +
 }
 return acc; // maybe boolean (acc != 0)
  
```

方法总结

修饰符和类型

方法

描述

abstract boolean

allTrue()

如果设置了所有掩码通道，则返回 true。

abstract VectorMask<E>

and(VectorMask<E> m)

计算此掩码和第二个输入掩码之间的逻辑交集（如 a&b ）。

abstract VectorMask<E>

andNot(VectorMask<E> m)

逻辑上从该掩码中减去第二个输入掩码（如 a&~b ）。

abstract boolean

anyTrue()

如果设置了任何掩码通道，则返回 true。

abstract <F> VectorMask<F>

cast(VectorSpecies<F> species)

将此掩码转换为元素类型为 F 的给定种类的掩码。

abstract <F> VectorMask<F>

check(Class<F> elementType)

检查此掩码是否适用于具有给定元素类型的向量，并返回此掩码不变。

abstract <F> VectorMask<F>

check(VectorSpecies<F> species)

检查此掩码是否具有给定的物种，并返回此掩码不变。

abstract VectorMask<E>

compress()

从此掩码中压缩设置的通道。

abstract VectorMask<E>

eq(VectorMask<E> m)

确定此掩码与第二个输入掩码的逻辑等效性（作为boolean a==b 或 a^~b ）。

final boolean

equals(Object obj)

指示此掩码是否与其他某个对象相同。

abstract int

firstTrue()

返回设置的第一个掩码通道的索引。

static <E> VectorMask<E>

fromArray(VectorSpecies<E> species, boolean[] bits, int offset)

从偏移量开始的 boolean 数组加载掩码。

static <E> VectorMask<E>

fromLong(VectorSpecies<E> species, long bits)

返回一个掩码，其中每个通道根据给定位掩码中的位设置或取消设置，从最低有效位开始，一直到符号位。

static <E> VectorMask<E>

fromValues(VectorSpecies<E> species, boolean... bits)

返回掩码，其中根据给定的 boolean 值设置或取消设置每个通道。

protected final Object

getPayload()

final int

hashCode()

根据掩码位设置和向量种类返回掩码的哈希码值。

abstract VectorMask<E>

indexInRange(int offset, int limit)

从此掩码中删除编号为 N 的通道，其中调整后的索引 N+offset 不在 [0..limit-1] 范围内。

abstract VectorMask<E>

indexInRange(long offset, long limit)

从此掩码中删除编号为 N 的通道，其中调整后的索引 N+offset 不在 [0..limit-1] 范围内。

abstract void

intoArray(boolean[] a, int offset)

将此掩码存储到从偏移量开始的 boolean 数组中。

abstract boolean

laneIsSet(int i)

测试索引 i 处的车道是否已设置

abstract int

lastTrue()

返回设置的最后一个掩码通道的索引。

final int

length()

返回掩码通道数。

abstract VectorMask<E>

not()

逻辑上否定这个掩码。

abstract VectorMask<E>

or(VectorMask<E> m)

计算此掩码和第二个输入掩码的逻辑并集（如 a|b ）。

abstract boolean[]

toArray()

返回包含此掩码的车道元素的 boolean 数组。

abstract long

toLong()

返回此掩码的车道元素，打包到最多前 64 个车道元素的 long 值中。

final String

toString()

返回此掩码的字符串表示形式，形式为 "Mask[T.TT...]" ，以通道顺序报告掩码位设置（作为“T”或“.”字符）。

abstract Vector<E>

toVector()

返回此掩码的向量表示，其通道位根据掩码位设置或取消设置。

abstract int

trueCount()

返回设置的掩码通道数。

abstract VectorSpecies<E>

vectorSpecies()

返回此掩码适用的矢量种类。

在类 java.lang.Object 中声明的方法
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

方法详情
- vectorSpecies
  
  public abstract VectorSpecies <E > vectorSpecies()
  
  返回此掩码适用的矢量种类。此掩码适用于同一物种和相同车道数的载体。
  
  返回：
  
  这个掩码的矢量种类
- length
  
  public final int length()
  
  返回掩码通道数。此掩码适用于相同车道数和相同物种的矢量。
  
  返回：
  
  掩码通道数
- fromValues
  
  public static <E> VectorMask <E> fromValues(VectorSpecies <E> species, boolean... bits)
  
  返回掩码，其中根据给定的 boolean 值设置或取消设置每个通道。
  对于每个掩码通道，其中 N 是掩码通道索引，如果索引 N 处的给定 boolean 值为 true，则设置索引 N 处的掩码通道，否则未设置。
  
  给定的物种必须有许多与给定阵列兼容的泳道。
  类型参数：
  
  E - 盒装元素类型
  
  参数：
  
  species - 所需掩码的矢量种类
  
  bits - 给定的 boolean 值
  
  返回：
  
  根据给定的 boolean 值设置或取消设置每个通道的掩码
  
  抛出：
  
  IllegalArgumentException - 如果 bits.length != species.length()
  
  参见：
  
  fromLong(VectorSpecies, long)
  
  fromArray(VectorSpecies, boolean[], int)
- fromArray
  
  public static <E> VectorMask <E> fromArray(VectorSpecies <E> species, boolean[] bits, int offset)
  
  从偏移量开始的 boolean 数组加载掩码。
  对于每个掩码通道，其中 N 是掩码通道索引，如果索引 offset + N 处的数组元素是 true，则设置索引 N 处的掩码通道，否则未设置。
  类型参数：
  
  E - 盒装元素类型
  
  参数：
  
  species - 所需掩码的矢量种类
  
  bits - boolean 阵列
  
  offset - 数组中的偏移量
  
  返回：
  
  从 boolean 数组加载的掩码
  
  抛出：
  
  IndexOutOfBoundsException - 如果 offset < 0 或 offset > bits.length - species.length()
  
  参见：
  
  fromLong(VectorSpecies, long)
  
  fromValues(VectorSpecies, boolean...)
- fromLong
  
  public static <E> VectorMask <E> fromLong(VectorSpecies <E> species, long bits)
  
  返回一个掩码，其中每个通道根据给定位掩码中的位设置或取消设置，从最低有效位开始，一直到符号位。
  对于每个掩码通道，其中 N 是掩码通道索引，如果表达式 (bits>>min(63,N))&1 不为零，则设置索引 N 处的掩码通道，否则未设置。
  
  如果给定的物种少于 64 条车道，则忽略位掩码的高 64-VLENGTH 位。如果给定的物种有超过 64 条泳道，则符号位将复制到第 64 道及以后的泳道。
  类型参数：
  
  E - 盒装元素类型
  
  参数：
  
  species - 所需掩码的矢量种类
  
  bits - 给定的掩码位，作为 64 位有符号整数
  
  返回：
  
  根据给定整数值中的位设置或取消设置每个通道的掩码
  
  参见：
  
  fromValues(VectorSpecies, boolean...)
  
  fromArray(VectorSpecies, boolean[], int)
- cast
  
  public abstract <F> VectorMask <F> cast(VectorSpecies <F> species)
  
  将此掩码转换为元素类型为 F 的给定种类的掩码。 species.length() 必须等于掩码长度。各种掩码通道位未修改。
  对于每个掩码通道，其中 N 是通道索引，如果设置了索引 N 处的掩码通道，则设置结果掩码的索引 N 处的掩码通道，否则不设置该掩码通道。
  
  类型参数：
  
  F - 物种的盒装元素类型
  
  参数：
  
  species - 所需掩码的矢量种类
  
  返回：
  
  由形状和元素类型转换的掩码
  
  抛出：
  
  IllegalArgumentException - 如果这个掩码长度和物种长度不同
- toLong
  
  public abstract long toLong()
  
  返回此掩码的车道元素，打包到最多前 64 个车道元素的 long 值中。
  通道元素按最低有效位到最高有效位的顺序打包。对于其中 N 是掩码通道索引的每个掩码通道，如果设置了掩码通道，则在生成的 long 值中将第 N 位设置为 1，否则将第 N 位设置为零。掩码的泳道不得超过 64 条。
  
  返回：
  
  此掩码的车道元素打包成一个 long 值。
  
  抛出：
  
  UnsupportedOperationException - 如果此掩码中有超过 64 条车道
- toArray
  
  public abstract boolean[] toArray()
  返回包含此掩码的车道元素的 boolean 数组。
  此方法的行为就像将此掩码存储到分配的数组中（使用 intoArray(boolean[], int) ）并返回该数组，如下所示：
  
  boolean[] a = new boolean[this.length()]; this.intoArray(a, 0); return a;
  返回：
  
  包含此向量的车道元素的数组
- intoArray
  
  public abstract void intoArray(boolean[] a, int offset)
  
  将此掩码存储到从偏移量开始的 boolean 数组中。
  对于每个掩码通道，其中 N 是掩码通道索引，索引 N 处的通道元素存储到数组元素 a[offset+N] 中。
  
  参数：
  
  a - 数组，类型为 boolean[]
  
  offset - 数组中的偏移量
  
  抛出：
  
  IndexOutOfBoundsException - 如果 offset < 0 或 offset > a.length - this.length()
- anyTrue
  
  public abstract boolean anyTrue()
  
  如果设置了任何掩码通道，则返回 true。
  
  返回：
  
  true 如果设置了任何掩码通道，否则 false 。
- allTrue
  
  public abstract boolean allTrue()
  
  如果设置了所有掩码通道，则返回 true。
  
  返回：
  
  true 如果设置了所有掩码通道，否则 false 。
- trueCount
  
  public abstract int trueCount()
  
  返回设置的掩码通道数。
  
  返回：
  
  设置的掩码通道数。
- firstTrue
  
  public abstract int firstTrue()
  
  返回设置的第一个掩码通道的索引。如果没有设置，则返回 VLENGTH。
  
  返回：
  
  设置的第一个掩码通道的索引，或 VLENGTH
- lastTrue
  
  public abstract int lastTrue()
  
  返回设置的最后一个掩码通道的索引。如果没有设置，则返回 -1。
  
  返回：
  
  设置的最后一个掩码通道的索引，或 -1
- and
  
  public abstract VectorMask <E > and(VectorMask <E > m)
  
  计算此掩码和第二个输入掩码之间的逻辑交集（如 a&b ）。
  这是一种逐通道二进制运算，它将逻辑 AND 运算 (&) 应用于每个对应的掩码位对。
  
  参数：
  
  m - 第二个输入掩码
  
  返回：
  
  逻辑上连接两个输入掩码的结果
- or
  
  public abstract VectorMask <E > or(VectorMask <E > m)
  
  计算此掩码和第二个输入掩码的逻辑并集（如 a|b ）。
  这是一种逐通道二进制运算，它将逻辑OR 运算 (|) 应用于每对对应的掩码位。
  
  参数：
  
  m - 输入掩码
  
  返回：
  
  逻辑上分离两个输入掩码的结果
- eq
  
  public abstract VectorMask <E > eq(VectorMask <E > m)
  
  确定此掩码与第二个输入掩码的逻辑等效性（作为boolean a==b 或 a^~b ）。
  这是一种逐通道二进制操作，测试每对对应的掩码位是否相等。它也等效于掩码位上的逆XOR操作（^~）。
  参数：
  
  m - 输入掩码
  
  返回：
  
  显示两个输入掩码相等位置的掩码
  
  参见：
  
  equals(java.lang.Object)
- andNot
  
  public abstract VectorMask <E > andNot(VectorMask <E > m)
  
  逻辑上从该掩码中减去第二个输入掩码（如 a&~b ）。
  这是一个车道级二进制操作，它将逻辑ANDC操作（&~）应用到每个对应的掩码位对。
  
  参数：
  
  m - 第二个输入掩码
  
  返回：
  
  从这个掩码中逻辑减去第二个掩码的结果
- not
  
  public abstract VectorMask <E > not()
  
  逻辑上否定这个掩码。
  这是一个车道级二进制操作，它将逻辑 NOT 操作 (~) 应用于每个掩码位。
  
  返回：
  
  逻辑上否定这个掩码的结果
- indexInRange
  
  public abstract VectorMask <E > indexInRange(int offset, int limit)
  
  从此掩码中删除编号为 N 的通道，其中调整后的索引 N+offset 不在 [0..limit-1] 范围内。
  在所有情况下，设置和未设置通道系列的分配就像使用无限精度或VLENGTH-饱和加法或减法一样，没有溢出或环绕。
  API 注意：
  
  此方法对 Objects.checkIndex(int,int) 对 [offset..offset+VLENGTH-1] 范围内的索引号执行的检查执行 SIMD 仿真。如果需要异常，则可以将生成的掩码与原始掩码进行比较；如果不相等，则至少有一条通道超出范围，可以进行异常处理。
  可以通过调用 allTrue.indexInRange(0, N) 获得掩码，该掩码是一系列 N 设置通道后跟一系列未设置通道，其中 allTrue 是所有真实位的掩码。可以通过调用 allTrue.indexInRange(-N1, N2) 获得 N1 未设置车道后跟 N2 设置车道的掩码。
  
  参数：
  
  offset - 起始索引
  
  limit - 索引范围的上限（不包括）
  
  返回：
  
  原始掩码，未设置超出范围的车道
  
  参见：
  
  VectorSpecies.indexInRange(int, int)
- indexInRange
  
  public abstract VectorMask <E > indexInRange(long offset, long limit)
  
  从此掩码中删除编号为 N 的通道，其中调整后的索引 N+offset 不在 [0..limit-1] 范围内。
  在所有情况下，设置和未设置通道系列的分配就像使用无限精度或VLENGTH-饱和加法或减法一样，没有溢出或环绕。
  API 注意：
  
  此方法对 Objects.checkIndex(long,long) 对 [offset..offset+VLENGTH-1] 范围内的索引号执行的检查执行 SIMD 仿真。如果需要异常，则可以将生成的掩码与原始掩码进行比较；如果不相等，则至少有一条通道超出范围，可以进行异常处理。
  可以通过调用 allTrue.indexInRange(0, N) 获得掩码，该掩码是一系列 N 设置通道后跟一系列未设置通道，其中 allTrue 是所有真实位的掩码。可以通过调用 allTrue.indexInRange(-N1, N2) 获得 N1 未设置车道后跟 N2 设置车道的掩码。
  
  参数：
  
  offset - 起始索引
  
  limit - 索引范围的上限（不包括）
  
  返回：
  
  原始掩码，未设置超出范围的车道
  
  自从：
  
  19
  
  参见：
  
  VectorSpecies.indexInRange(long, long)
- toVector
  
  public abstract Vector <E > toVector()
  
  返回此掩码的向量表示，其通道位根据掩码位设置或取消设置。对于每个掩码通道，其中 N 是掩码通道索引，如果掩码通道设置为 N，则将特定非默认值 -1 放入通道索引 N 处的结果向量中。否则，默认元素值 0 被放入车道索引 N 处的结果向量中。无论此掩码的元素类型 (ETYPE) 是浮点型还是整数，掩码选择的通道值将是两个算术值 0 或 -1 之一。对于每个 ETYPE，当且仅当设置了掩码通道时，才会设置向量通道的最高有效位。此外，对于整数类型，在设置掩码的通道中设置all通道位。
  返回的向量与 ZERO.blend(MINUS_ONE, this) 计算的向量相同，其中 ZERO 和 MINUS_ONE 是分别复制默认 ETYPE 值和代表 -1 的 ETYPE 值的向量。
  API 注意：
  
  为了进行静态类型检查，用户可能希望根据预期的整体车道类型或物种检查结果向量。如果掩码用于浮点数种类，则生成的向量将具有相同的形状和泳道大小，但为整型。如果掩码用于完整物种，则生成的向量将恰好属于该物种。
  
  返回：
  
  此掩码的矢量表示
  
  参见：
  
  Vector.check(Class)
  
  Vector.check(VectorSpecies)
- laneIsSet
  
  public abstract boolean laneIsSet(int i)
  
  测试索引 i 处的车道是否已设置
  
  参数：
  
  i - 车道索引
  
  返回：
  
  如果索引 i 处的车道已设置，则为 true，否则为 false
  
  抛出：
  
  IndexOutOfBoundsException - 如果索引超出范围 (< 0 || >= length())
- check
  
  public abstract <F> VectorMask <F> check(Class <F> elementType)
  
  检查此掩码是否适用于具有给定元素类型的向量，并返回此掩码不变。效果类似于此伪代码：elementType == vectorSpecies().elementType() ? this : throw new ClassCastException()。
  类型参数：
  
  F - 所需车道类型的盒装元素类型
  
  参数：
  
  elementType - 所需的车道类型
  
  返回：
  
  同一个掩码
  
  抛出：
  
  ClassCastException - 如果元素类型错误
  
  参见：
  
  Vector.check(Class)
  
  check(VectorSpecies)
- check
  
  public abstract <F> VectorMask <F> check(VectorSpecies <F> species)
  
  检查此掩码是否具有给定的物种，并返回此掩码不变。效果类似于此伪代码：species == vectorSpecies() ? this : throw new ClassCastException()。
  类型参数：
  
  F - 所需物种的盒装元素类型
  
  参数：
  
  species - 此面罩所需的载体种类
  
  返回：
  
  同一个掩码
  
  抛出：
  
  ClassCastException - 如果物种错误
  
  参见：
  
  Vector.check(Class)
  
  Vector.check(VectorSpecies)
- toString
  
  public final String toString()
  
  返回此掩码的字符串表示形式，形式为 "Mask[T.TT...]" ，以通道顺序报告掩码位设置（作为“T”或“.”字符）。
  
  重写：
  
  toString 在类 Object 中
  
  返回：
  
  "Mask[T.TT...]" 形式的字符串
- equals
  
  public final boolean equals(Object obj)
  
  指示此掩码是否与其他某个对象相同。只有当两个口罩具有相同的物种和相同的来源索引、相同的顺序时，它们才是相同的。
  重写：
  
  equals 在类 Object 中
  
  参数：
  
  obj - 要比较的参考对象。
  
  返回：
  
  此向量是否与其他某个对象相同
  
  参见：
  
  eq(jdk.incubator.vector.VectorMask<E>)
- hashCode
  
  public final int hashCode()
  
  根据掩码位设置和向量种类返回掩码的哈希码值。
  重写：
  
  hashCode 在类 Object 中
  
  返回：
  
  此掩码的哈希码值
  
  参见：
  
  Object.equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- compress
  
  public abstract VectorMask <E > compress()
  
  从此掩码中压缩设置的通道。返回一个掩码，它是一系列 N 设置通道，后跟一系列未设置的通道，其中 N 是该掩码的真实计数。
  
  返回：
  
  该掩码的压缩掩码
  
  自从：
  
  19
- getPayload
  
  protected final Object getPayload()

类 VectorMask<E>

基于值的类和身份操作

方法总结

在类 java.lang.Object 中声明的方法

方法详情

vectorSpecies

length

fromValues

fromArray

fromLong

cast

toLong

toArray

intoArray

anyTrue

allTrue

trueCount

firstTrue

lastTrue

and

or

eq

andNot

not

indexInRange

indexInRange

toVector

laneIsSet

check

check

toString

equals

hashCode

compress

getPayload