クラスjdk.incubator.vector.VectorMaskの
使用

VectorMaskを使用するパッケージ
パッケージ
説明
jdk.incubator.vector

インキュベート機能。 将来のリリースで削除されます。

  • jdk.incubator.vectorでのVectorMaskの使用

    VectorMaskを返すjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    abstract VectorMask<E>
    VectorMask.and(VectorMask<E> m)
    このマスクと2番目の入力マスク間の論理積(a&bとして)を計算します。
    abstract VectorMask<E>
    VectorMask.andNot(VectorMask<E> m)
    このマスク(a&~bとして)から別の入力マスクを論理的に減算します。
    abstract <F> VectorMask<F>
    VectorMask.cast(VectorSpecies<F> species)
    このマスクを、指定された種の要素型Fのマスクに変換します。
    abstract <F> VectorMask<F>
    VectorMask.check(Class<F> elementType)
    このマスクが指定された要素型のベクトルに適用されることを確認し、このマスクをそのまま返します。
    abstract <F> VectorMask<F>
    VectorMask.check(VectorSpecies<F> species)
    このマスクが指定された種を持っていることを確認し、このマスクをそのまま返します。
    abstract VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, byte e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, Vector<Byte> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, double e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, double e, VectorMask<Double> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, long e, VectorMask<Double> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, Vector<Double> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, float e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, long e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, Vector<Float> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, int e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, Vector<Integer> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Long>
    LongVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Long>
    LongVector.compare(VectorOperators.Comparison op, long e, VectorMask<Long> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Long>
    LongVector.compare(VectorOperators.Comparison op, Vector<Long> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, long e, VectorMask<Short> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, short e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, short e, VectorMask<Short> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, Vector<Short> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, long e, VectorMask<E> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, Vector<E> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)
    このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。
    abstract VectorMask<E>
    VectorMask.compress()
    このマスクからセット・レーンを圧縮します。
    final VectorMask<Byte>
    ByteVector.eq(byte e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Byte>
    ByteVector.eq(Vector<Byte> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.eq(double e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.eq(Vector<Double> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.eq(float e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.eq(Vector<Float> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.eq(int e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.eq(Vector<Integer> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Long>
    LongVector.eq(long e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Long>
    LongVector.eq(Vector<Long> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.eq(short e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.eq(Vector<Short> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    abstract VectorMask<E>
    Vector.eq(Vector<E> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    abstract VectorMask<E>
    VectorMask.eq(VectorMask<E> m)
    このマスクと別の入力マスク(ブールa==bまたはa^~bとして)との論理的な等価性を判定します。
    static <E> VectorMask<E>
    VectorMask.fromArray(VectorSpecies<E> species, boolean[] bits, int offset)
    オフセットから始まるboolean配列からマスクをロードします。
    static <E> VectorMask<E>
    VectorMask.fromLong(VectorSpecies<E> species, long bits)
    指定されたビット・マスク内のビットに従って、最下位ビットから符号ビットまで、各レーンが設定または設定解除されているマスクを返します。
    static <E> VectorMask<E>
    VectorMask.fromValues(VectorSpecies<E> species, boolean... bits)
    指定されたboolean値に従って各レーンが設定または設定解除されるマスクを返します。
    abstract VectorMask<E>
    VectorMask.indexInRange(int offset, int limit)
    調整された索引N+offsetが[0..limit-1]の範囲内にない場合に、このマスクからレーン番号付きNを削除します。
    abstract VectorMask<E>
    VectorMask.indexInRange(long offset, long limit)
    調整された索引N+offsetが[0..limit-1]の範囲内にない場合に、このマスクからレーン番号付きNを削除します。
    VectorMask<E>
    VectorSpecies.indexInRange(int offset, int limit)
    調整されたインデックスN+offsetが[0..limit-1]の範囲内にあるように、インデックスNのレーンだけが設定されているこの種のマスクを返します。
    VectorMask<E>
    VectorSpecies.indexInRange(long offset, long limit)
    調整されたインデックスN+offsetが[0..limit-1]の範囲内にあるように、インデックスNのレーンだけが設定されているこの種のマスクを返します。
    abstract VectorMask<E>
    VectorShuffle.laneIsValid()
    有効な索引(負でない値)を含むすべてのレーンを検索し、それらのレーンが正確に設定されているマスクを返します。
    VectorMask<E>
    VectorSpecies.loadMask(boolean[] bits, int offset)
    指定されたオフセットの指定された配列からレーン要素が初期化される、この種のマスクを返します。
    final VectorMask<Byte>
    ByteVector.lt(byte e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Byte>
    ByteVector.lt(Vector<Byte> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.lt(double e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.lt(Vector<Double> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.lt(float e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.lt(Vector<Float> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.lt(int e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.lt(Vector<Integer> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Long>
    LongVector.lt(long e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Long>
    LongVector.lt(Vector<Long> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.lt(short e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.lt(Vector<Short> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    abstract VectorMask<E>
    Vector.lt(Vector<E> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    abstract VectorMask<E>
    Vector.maskAll(boolean bit)
    このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。
    VectorMask<E>
    VectorSpecies.maskAll(boolean bit)
    この種のマスクを返します。各レーンは、指定された単一のbooleanに従って設定または設定解除され、すべてのレーンにブロードキャストされます。
    abstract VectorMask<E>
    VectorMask.not()
    このマスクを論理的に否定します。
    abstract VectorMask<E>
    VectorMask.or(VectorMask<E> m)
    このマスクと別の入力マスクの論理和集合(a|bとして)を計算します。
    abstract VectorMask<Byte>
    ByteVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Byte>
    ByteVector.test(VectorOperators.Test op, VectorMask<Byte> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Double>
    DoubleVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Double>
    DoubleVector.test(VectorOperators.Test op, VectorMask<Double> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Float>
    FloatVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Float>
    FloatVector.test(VectorOperators.Test op, VectorMask<Float> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Integer>
    IntVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Integer>
    IntVector.test(VectorOperators.Test op, VectorMask<Integer> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Long>
    LongVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Long>
    LongVector.test(VectorOperators.Test op, VectorMask<Long> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Short>
    ShortVector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<Short>
    ShortVector.test(VectorOperators.Test op, VectorMask<Short> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<E>
    Vector.test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    abstract VectorMask<E>
    Vector.test(VectorOperators.Test op, VectorMask<E> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<E>
    VectorMask.xor(VectorMask<E> m)
    このマスクと2番目の入力マスクの論理対称差(a^bとして)を決定します。
    型VectorMaskの引数を持つ型を返すjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    Class<? extends VectorMask<E>>
    VectorSpecies.maskType()
    この種のベクトル・マスク・タイプを返します。
    型VectorMaskのパラメータを持つjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    final ByteVector
    ByteVector.add(byte e, VectorMask<Byte> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final ByteVector
    ByteVector.add(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final DoubleVector
    DoubleVector.add(double e, VectorMask<Double> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final DoubleVector
    DoubleVector.add(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final FloatVector
    FloatVector.add(float e, VectorMask<Float> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    FloatVector.add(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final IntVector
    IntVector.add(int e, VectorMask<Integer> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final IntVector
    IntVector.add(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final LongVector
    LongVector.add(long e, VectorMask<Long> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final LongVector
    LongVector.add(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final ShortVector
    ShortVector.add(short e, VectorMask<Short> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final ShortVector
    ShortVector.add(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    Vector.add(Vector<E> v, VectorMask<E> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract VectorMask<E>
    VectorMask.and(VectorMask<E> m)
    このマスクと2番目の入力マスク間の論理積(a&bとして)を計算します。
    abstract VectorMask<E>
    VectorMask.andNot(VectorMask<E> m)
    このマスク(a&~bとして)から別の入力マスクを論理的に減算します。
    final ByteVector
    ByteVector.blend(byte e, VectorMask<Byte> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final ByteVector
    ByteVector.blend(long e, VectorMask<Byte> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract ByteVector
    ByteVector.blend(Vector<Byte> v, VectorMask<Byte> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final DoubleVector
    DoubleVector.blend(double e, VectorMask<Double> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final DoubleVector
    DoubleVector.blend(long e, VectorMask<Double> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract DoubleVector
    DoubleVector.blend(Vector<Double> v, VectorMask<Double> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final FloatVector
    FloatVector.blend(float e, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final FloatVector
    FloatVector.blend(long e, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract FloatVector
    FloatVector.blend(Vector<Float> v, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final IntVector
    IntVector.blend(int e, VectorMask<Integer> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final IntVector
    IntVector.blend(long e, VectorMask<Integer> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract IntVector
    IntVector.blend(Vector<Integer> v, VectorMask<Integer> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final LongVector
    LongVector.blend(long e, VectorMask<Long> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract LongVector
    LongVector.blend(Vector<Long> v, VectorMask<Long> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final ShortVector
    ShortVector.blend(long e, VectorMask<Short> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final ShortVector
    ShortVector.blend(short e, VectorMask<Short> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract ShortVector
    ShortVector.blend(Vector<Short> v, VectorMask<Short> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract Vector<E>
    Vector.blend(long e, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract Vector<E>
    Vector.blend(Vector<E> v, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    final VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, double e, VectorMask<Double> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, long e, VectorMask<Double> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, long e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Long>
    LongVector.compare(VectorOperators.Comparison op, long e, VectorMask<Long> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, long e, VectorMask<Short> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, short e, VectorMask<Short> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, long e, VectorMask<E> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<E>
    Vector.compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)
    このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。
    abstract ByteVector
    ByteVector.compress(VectorMask<Byte> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract DoubleVector
    DoubleVector.compress(VectorMask<Double> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract FloatVector
    FloatVector.compress(VectorMask<Float> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract IntVector
    IntVector.compress(VectorMask<Integer> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract LongVector
    LongVector.compress(VectorMask<Long> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract ShortVector
    ShortVector.compress(VectorMask<Short> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract Vector<E>
    Vector.compress(VectorMask<E> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    final ByteVector
    ByteVector.div(byte e, VectorMask<Byte> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final ByteVector
    ByteVector.div(Vector<Byte> v, VectorMask<Byte> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final DoubleVector
    DoubleVector.div(double e, VectorMask<Double> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final DoubleVector
    DoubleVector.div(Vector<Double> v, VectorMask<Double> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final FloatVector
    FloatVector.div(float e, VectorMask<Float> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    FloatVector.div(Vector<Float> v, VectorMask<Float> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final IntVector
    IntVector.div(int e, VectorMask<Integer> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final IntVector
    IntVector.div(Vector<Integer> v, VectorMask<Integer> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final LongVector
    LongVector.div(long e, VectorMask<Long> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final LongVector
    LongVector.div(Vector<Long> v, VectorMask<Long> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final ShortVector
    ShortVector.div(short e, VectorMask<Short> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final ShortVector
    ShortVector.div(Vector<Short> v, VectorMask<Short> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    abstract Vector<E>
    Vector.div(Vector<E> v, VectorMask<E> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    abstract VectorMask<E>
    VectorMask.eq(VectorMask<E> m)
    このマスクと別の入力マスク(ブールa==bまたはa^~bとして)との論理的な等価性を判定します。
    abstract ByteVector
    ByteVector.expand(VectorMask<Byte> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract DoubleVector
    DoubleVector.expand(VectorMask<Double> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract FloatVector
    FloatVector.expand(VectorMask<Float> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract IntVector
    IntVector.expand(VectorMask<Integer> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract LongVector
    LongVector.expand(VectorMask<Long> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract ShortVector
    ShortVector.expand(VectorMask<Short> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    abstract Vector<E>
    Vector.expand(VectorMask<E> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    static ByteVector
    ByteVector.fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
    マスクの制御下にあるbyte[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static ByteVector
    ByteVector.fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)
    オフセットからマスクを使用して、byte[]型の配列からベクトルをロードします。
    static DoubleVector
    DoubleVector.fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)
    マスクの制御下にあるdouble[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static DoubleVector
    DoubleVector.fromArray(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m)
    オフセットからマスクを使用して、double[]型の配列からベクトルをロードします。
    static FloatVector
    FloatVector.fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
    マスクの制御下にあるfloat[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static FloatVector
    FloatVector.fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)
    オフセットからマスクを使用して、float[]型の配列からベクトルをロードします。
    static IntVector
    IntVector.fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)
    マスクの制御下にあるint[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static IntVector
    IntVector.fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)
    オフセットからマスクを使用して、int[]型の配列からベクトルをロードします。
    static LongVector
    LongVector.fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)
    マスクの制御下にあるlong[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static LongVector
    LongVector.fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)
    オフセットからマスクを使用して、long[]型の配列からベクトルをロードします。
    static ShortVector
    ShortVector.fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)
    マスクの制御下にあるshort[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static ShortVector
    ShortVector.fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)
    オフセットからマスクを使用して、short[]型の配列からベクトルをロードします。
    static ByteVector
    ByteVector.fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
    マスクの制御下にあるboolean[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static ByteVector
    ByteVector.fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)
    オフセットからマスクを使用して、boolean[]型の配列からベクトルをロードします。
    static ShortVector
    ShortVector.fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)
    マスクの制御下にあるchar[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static ShortVector
    ShortVector.fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)
    オフセットからマスクを使用して、char[]型の配列からベクトルをロードします。
    static ByteVector
    ByteVector.fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    static DoubleVector
    DoubleVector.fromMemorySegment(VectorSpecies<Double> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Double> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    static FloatVector
    FloatVector.fromMemorySegment(VectorSpecies<Float> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    static IntVector
    IntVector.fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    static LongVector
    LongVector.fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    static ShortVector
    ShortVector.fromMemorySegment(VectorSpecies<Short> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Short> m)
    オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。
    final void
    ByteVector.intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
    このベクトルを、マスクの制御下にあるbyte[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    ByteVector.intoArray(byte[] a, int offset, VectorMask<Byte> m)
    このベクトルを、オフセットから始めてマスクを使用するbyte[]型の配列に格納します。
    final void
    DoubleVector.intoArray(double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)
    このベクトルを、マスクの制御下にあるdouble[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    DoubleVector.intoArray(double[] a, int offset, VectorMask<Double> m)
    このベクトルを、オフセットから始めてマスクを使用するdouble[]型の配列に格納します。
    final void
    FloatVector.intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
    このベクトルを、マスクの制御下にあるfloat[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    FloatVector.intoArray(float[] a, int offset, VectorMask<Float> m)
    このベクトルを、オフセットから始めてマスクを使用するfloat[]型の配列に格納します。
    final void
    IntVector.intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)
    このベクトルを、マスクの制御下にあるint[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    IntVector.intoArray(int[] a, int offset, VectorMask<Integer> m)
    このベクトルを、オフセットから始めてマスクを使用するint[]型の配列に格納します。
    final void
    LongVector.intoArray(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)
    このベクトルを、マスクの制御下にあるlong[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    LongVector.intoArray(long[] a, int offset, VectorMask<Long> m)
    このベクトルを、オフセットから始めてマスクを使用するlong[]型の配列に格納します。
    final void
    ShortVector.intoArray(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)
    このベクトルを、マスクの制御下にあるshort[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    ShortVector.intoArray(short[] a, int offset, VectorMask<Short> m)
    このベクトルを、オフセットから始めてマスクを使用するshort[]型の配列に格納します。
    final void
    ByteVector.intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
    このベクトルを、マスクの制御下にあるboolean[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    ByteVector.intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m)
    このベクトルを、オフセットから始めてマスクを使用するboolean[]型の配列に格納します。
    final void
    ShortVector.intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)
    このベクトルを、マスクの制御下にあるchar[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    ShortVector.intoCharArray(char[] a, int offset, VectorMask<Short> m)
    このベクトルを、オフセットから始めてマスクを使用するchar[]型の配列に格納します。
    final void
    ByteVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final void
    DoubleVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Double> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final void
    FloatVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final void
    IntVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final void
    LongVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final void
    ShortVector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Short> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    abstract void
    Vector.intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<E> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Unary op, VectorMask<Byte> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Binary op, double e, VectorMask<Double> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Double> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, double e1, double e2, VectorMask<Double> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Unary op, VectorMask<Double> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Float> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Unary op, VectorMask<Float> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final IntVector
    IntVector.lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    final IntVector
    IntVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final IntVector
    IntVector.lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final IntVector
    IntVector.lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final IntVector
    IntVector.lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Unary op, VectorMask<Integer> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final LongVector
    LongVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Long> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Binary op, Vector<Long> v, VectorMask<Long> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final LongVector
    LongVector.lanewise(VectorOperators.Ternary op, long e1, long e2, VectorMask<Long> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final LongVector
    LongVector.lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2, VectorMask<Long> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final LongVector
    LongVector.lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2, VectorMask<Long> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Unary op, VectorMask<Long> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Binary op, long e, VectorMask<Short> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Binary op, short e, VectorMask<Short> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Binary op, Vector<Short> v, VectorMask<Short> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, short e1, short e2, VectorMask<Short> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2, VectorMask<Short> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2, VectorMask<Short> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2, VectorMask<Short> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Unary op, VectorMask<Short> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Binary op, long e, VectorMask<E> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Unary op, VectorMask<E> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final ByteVector
    ByteVector.mul(byte e, VectorMask<Byte> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final ByteVector
    ByteVector.mul(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final DoubleVector
    DoubleVector.mul(double e, VectorMask<Double> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final DoubleVector
    DoubleVector.mul(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final FloatVector
    FloatVector.mul(float e, VectorMask<Float> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    FloatVector.mul(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final IntVector
    IntVector.mul(int e, VectorMask<Integer> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final IntVector
    IntVector.mul(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final LongVector
    LongVector.mul(long e, VectorMask<Long> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final LongVector
    LongVector.mul(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final ShortVector
    ShortVector.mul(short e, VectorMask<Short> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final ShortVector
    ShortVector.mul(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    abstract Vector<E>
    Vector.mul(Vector<E> v, VectorMask<E> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    abstract VectorMask<E>
    VectorMask.or(VectorMask<E> m)
    このマスクと別の入力マスクの論理和集合(a|bとして)を計算します。
    abstract ByteVector
    ByteVector.rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract DoubleVector
    DoubleVector.rearrange(VectorShuffle<Double> s, VectorMask<Double> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract FloatVector
    FloatVector.rearrange(VectorShuffle<Float> s, VectorMask<Float> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract IntVector
    IntVector.rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract LongVector
    LongVector.rearrange(VectorShuffle<Long> s, VectorMask<Long> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract ShortVector
    ShortVector.rearrange(VectorShuffle<Short> s, VectorMask<Short> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract Vector<E>
    Vector.rearrange(VectorShuffle<E> s, VectorMask<E> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract byte
    ByteVector.reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract double
    DoubleVector.reduceLanes(VectorOperators.Associative op, VectorMask<Double> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract float
    FloatVector.reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract int
    IntVector.reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract long
    LongVector.reduceLanes(VectorOperators.Associative op, VectorMask<Long> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract short
    ShortVector.reduceLanes(VectorOperators.Associative op, VectorMask<Short> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract long
    Vector.reduceLanesToLong(VectorOperators.Associative op, VectorMask<E> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract ByteVector
    ByteVector.selectFrom(Vector<Byte> s, VectorMask<Byte> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract DoubleVector
    DoubleVector.selectFrom(Vector<Double> s, VectorMask<Double> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract FloatVector
    FloatVector.selectFrom(Vector<Float> s, VectorMask<Float> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract IntVector
    IntVector.selectFrom(Vector<Integer> s, VectorMask<Integer> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract LongVector
    LongVector.selectFrom(Vector<Long> s, VectorMask<Long> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract ShortVector
    ShortVector.selectFrom(Vector<Short> s, VectorMask<Short> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract Vector<E>
    Vector.selectFrom(Vector<E> v, VectorMask<E> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    final ByteVector
    ByteVector.slice(int origin, Vector<Byte> w, VectorMask<Byte> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final DoubleVector
    DoubleVector.slice(int origin, Vector<Double> w, VectorMask<Double> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final FloatVector
    FloatVector.slice(int origin, Vector<Float> w, VectorMask<Float> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final IntVector
    IntVector.slice(int origin, Vector<Integer> w, VectorMask<Integer> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final LongVector
    LongVector.slice(int origin, Vector<Long> w, VectorMask<Long> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final ShortVector
    ShortVector.slice(int origin, Vector<Short> w, VectorMask<Short> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract Vector<E>
    Vector.slice(int origin, Vector<E> v1, VectorMask<E> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final ByteVector
    ByteVector.sub(byte e, VectorMask<Byte> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final ByteVector
    ByteVector.sub(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final DoubleVector
    DoubleVector.sub(double e, VectorMask<Double> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final DoubleVector
    DoubleVector.sub(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final FloatVector
    FloatVector.sub(float e, VectorMask<Float> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final FloatVector
    FloatVector.sub(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final IntVector
    IntVector.sub(int e, VectorMask<Integer> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final IntVector
    IntVector.sub(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final LongVector
    LongVector.sub(long e, VectorMask<Long> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final LongVector
    LongVector.sub(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final ShortVector
    ShortVector.sub(short e, VectorMask<Short> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final ShortVector
    ShortVector.sub(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract Vector<E>
    Vector.sub(Vector<E> v, VectorMask<E> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract VectorMask<Byte>
    ByteVector.test(VectorOperators.Test op, VectorMask<Byte> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Double>
    DoubleVector.test(VectorOperators.Test op, VectorMask<Double> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Float>
    FloatVector.test(VectorOperators.Test op, VectorMask<Float> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Integer>
    IntVector.test(VectorOperators.Test op, VectorMask<Integer> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Long>
    LongVector.test(VectorOperators.Test op, VectorMask<Long> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<Short>
    ShortVector.test(VectorOperators.Test op, VectorMask<Short> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract VectorMask<E>
    Vector.test(VectorOperators.Test op, VectorMask<E> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    abstract ByteVector
    ByteVector.unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract DoubleVector
    DoubleVector.unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract FloatVector
    FloatVector.unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract IntVector
    IntVector.unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract LongVector
    LongVector.unslice(int origin, Vector<Long> w, int part, VectorMask<Long> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract ShortVector
    ShortVector.unslice(int origin, Vector<Short> w, int part, VectorMask<Short> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract Vector<E>
    Vector.unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract VectorMask<E>
    VectorMask.xor(VectorMask<E> m)
    このマスクと2番目の入力マスクの論理対称差(a^bとして)を決定します。