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

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

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

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

    jdk.incubator.vectorのVectorのサブクラス
    修飾子と型
    クラス
    説明
    class 
    ByteVector
    順序付けられた不変のbyte値のシーケンスを表す特殊なVector。
    class 
    DoubleVector
    順序付けられた不変のdouble値のシーケンスを表す特殊なVector。
    class 
    FloatVector
    順序付けられた不変のfloat値のシーケンスを表す特殊なVector。
    class 
    IntVector
    順序付けられた不変のint値のシーケンスを表す特殊なVector。
    class 
    LongVector
    順序付けられた不変のlong値のシーケンスを表す特殊なVector。
    class 
    ShortVector
    順序付けられた不変のshort値のシーケンスを表す特殊なVector。
    Vectorを返すjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    abstract Vector<E>
    Vector.abs()
    このベクトルの絶対値を返します。
    abstract Vector<E>
    Vector.add(Vector<E> v)
    このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    Vector.add(Vector<E> v, VectorMask<E> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    Vector.addIndex(int scale)
    指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。
    abstract Vector<E>
    Vector.blend(long e, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract Vector<E>
    Vector.blend(Vector<E> v, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract Vector<E>
    Vector.broadcast(long e)
    すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。
    Vector<E>
    VectorSpecies.broadcast(long e)
    すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。
    abstract <F> Vector<F>
    Vector.castShape(VectorSpecies<F> rsp, int part)
    ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。
    abstract <F> Vector<F>
    Vector.check(Class<F> elementType)
    このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。
    abstract <F> Vector<F>
    Vector.check(VectorSpecies<F> species)
    このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。
    abstract Vector<E>
    Vector.compress(VectorMask<E> m)
    特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。
    abstract <F> Vector<F>
    Vector.convert(VectorOperators.Conversion<E,F> conv, int part)
    指定された「変換」に従って、このベクトルを同じシェイプのベクトルおよび新しい要素タイプに変換し、レーン値を現在のETYPEから新しいレーン型の(ここではFTYPEと呼びます)に変換します。
    abstract <F> Vector<F>
    Vector.convertShape(VectorOperators.Conversion<E,F> conv, VectorSpecies<F> rsp, int part)
    指定された「変換」に従って、このベクトルを指定された種、シェイプ、および要素型のベクトルに変換し、レーン値を現在のETYPEから新しいレーン型(ここではFTYPEと呼びます)に変換します。
    abstract Vector<E>
    Vector.div(Vector<E> v)
    このベクトルを2番目の入力ベクトルで除算します。
    abstract Vector<E>
    Vector.div(Vector<E> v, VectorMask<E> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    abstract Vector<E>
    Vector.expand(VectorMask<E> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    Vector<E>
    VectorSpecies.fromArray(Object a, int offset)
    指定されたオフセットの指定された配列からレーン要素が初期化される、この種のベクトルを返します。
    Vector<E>
    VectorSpecies.fromMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
    オフセットから始まる「メモリー・セグメント」PREVIEWからこの種のベクトルをメモリー・セグメントにロードします。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Binary op, long e)
    このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    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)
    このベクトルのレーン値を操作します。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Unary op, VectorMask<E> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    abstract Vector<E>
    Vector.max(Vector<E> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    abstract Vector<E>
    Vector.min(Vector<E> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    abstract Vector<E>
    Vector.mul(Vector<E> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    abstract Vector<E>
    Vector.mul(Vector<E> v, VectorMask<E> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    abstract Vector<E>
    Vector.neg()
    このベクトルを否定します。
    abstract Vector<E>
    Vector.rearrange(VectorShuffle<E> s)
    特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract Vector<E>
    Vector.rearrange(VectorShuffle<E> s, Vector<E> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract Vector<E>
    Vector.rearrange(VectorShuffle<E> s, VectorMask<E> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract <F> Vector<F>
    Vector.reinterpretShape(VectorSpecies<F> species, int part)
    値の変換を実行せずに、このベクトルを要素型Fの指定された種のベクトルに変換し、このベクトルのバイトを再解釈します。
    abstract Vector<E>
    Vector.selectFrom(Vector<E> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract Vector<E>
    Vector.selectFrom(Vector<E> v, VectorMask<E> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract Vector<E>
    Vector.slice(int origin)
    現在のベクトル内の指定されたoriginレーンから始まる隣接レーンのセグメントをスライスします。
    abstract Vector<E>
    Vector.slice(int origin, Vector<E> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    abstract Vector<E>
    Vector.slice(int origin, Vector<E> v1, VectorMask<E> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract Vector<E>
    Vector.sub(Vector<E> v)
    このベクトルから2番目の入力ベクトルを減算します。
    abstract Vector<E>
    Vector.sub(Vector<E> v, VectorMask<E> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract Vector<E>
    VectorMask.toVector()
    このマスクのベクトル表現を返します。そのレーン・ビットは、マスク・ビットに対応して設定または設定解除されます。
    abstract Vector<E>
    VectorShuffle.toVector()
    このシャッフルをベクトルに変換し、シャッフルのレーンのソース・インデックスに対応する整数値のベクトルを作成します。
    abstract Vector<E>
    Vector.unslice(int origin)
    slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。
    abstract Vector<E>
    Vector.unslice(int origin, Vector<E> w, int part)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract Vector<E>
    Vector.unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    final Vector<?>
    ByteVector.viewAsFloatingLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。
    final Vector<?>
    ShortVector.viewAsFloatingLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。
    abstract Vector<?>
    Vector.viewAsFloatingLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。
    abstract Vector<?>
    Vector.viewAsIntegralLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。
    Vector<E>
    VectorSpecies.zero()
    すべてのレーン要素がデフォルトのプリミティブ値である(ETYPE)0に設定されている、この種のベクトルを返します。
    型Vectorの引数を持つ型を返すjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    Class<? extends Vector<E>>
    VectorSpecies.vectorType()
    この種のベクトル型を返します。
    型Vectorのパラメータを持つjdk.incubator.vectorのメソッド
    修飾子と型
    メソッド
    説明
    final ByteVector
    ByteVector.add(Vector<Byte> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final ByteVector
    ByteVector.add(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final DoubleVector
    DoubleVector.add(Vector<Double> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final DoubleVector
    DoubleVector.add(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final FloatVector
    FloatVector.add(Vector<Float> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final FloatVector
    FloatVector.add(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final IntVector
    IntVector.add(Vector<Integer> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final IntVector
    IntVector.add(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final LongVector
    LongVector.add(Vector<Long> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final LongVector
    LongVector.add(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final ShortVector
    ShortVector.add(Vector<Short> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final ShortVector
    ShortVector.add(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    Vector.add(Vector<E> v)
    このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    Vector.add(Vector<E> v, VectorMask<E> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    final ByteVector
    ByteVector.and(Vector<Byte> v)
    このベクトルと次の入力ベクトルのビット単位の論理積(&)を計算します。
    final IntVector
    IntVector.and(Vector<Integer> v)
    このベクトルと次の入力ベクトルのビット単位の論理積(&)を計算します。
    final LongVector
    LongVector.and(Vector<Long> v)
    このベクトルと次の入力ベクトルのビット単位の論理積(&)を計算します。
    final ShortVector
    ShortVector.and(Vector<Short> v)
    このベクトルと次の入力ベクトルのビット単位の論理積(&)を計算します。
    final ByteVector
    ByteVector.bitwiseBlend(byte bits, Vector<Byte> mask)
    マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。
    final ByteVector
    ByteVector.bitwiseBlend(Vector<Byte> bits, byte mask)
    マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。
    final ByteVector
    ByteVector.bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)
    マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。
    final IntVector
    IntVector.bitwiseBlend(int bits, Vector<Integer> mask)
    マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。
    final IntVector
    IntVector.bitwiseBlend(Vector<Integer> bits, int mask)
    マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。
    final IntVector
    IntVector.bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)
    マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。
    final LongVector
    LongVector.bitwiseBlend(long bits, Vector<Long> mask)
    マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。
    final LongVector
    LongVector.bitwiseBlend(Vector<Long> bits, long mask)
    マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。
    final LongVector
    LongVector.bitwiseBlend(Vector<Long> bits, Vector<Long> mask)
    マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。
    final ShortVector
    ShortVector.bitwiseBlend(short bits, Vector<Short> mask)
    マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。
    final ShortVector
    ShortVector.bitwiseBlend(Vector<Short> bits, short mask)
    マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。
    final ShortVector
    ShortVector.bitwiseBlend(Vector<Short> bits, Vector<Short> mask)
    マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。
    abstract ByteVector
    ByteVector.blend(Vector<Byte> v, VectorMask<Byte> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract DoubleVector
    DoubleVector.blend(Vector<Double> v, VectorMask<Double> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract FloatVector
    FloatVector.blend(Vector<Float> v, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract IntVector
    IntVector.blend(Vector<Integer> v, VectorMask<Integer> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract LongVector
    LongVector.blend(Vector<Long> v, VectorMask<Long> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract ShortVector
    ShortVector.blend(Vector<Short> v, VectorMask<Short> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract Vector<E>
    Vector.blend(Vector<E> v, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract VectorMask<Byte>
    ByteVector.compare(VectorOperators.Comparison op, Vector<Byte> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Double>
    DoubleVector.compare(VectorOperators.Comparison op, Vector<Double> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    FloatVector.compare(VectorOperators.Comparison op, Vector<Float> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Integer>
    IntVector.compare(VectorOperators.Comparison op, Vector<Integer> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Long>
    LongVector.compare(VectorOperators.Comparison op, Vector<Long> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    abstract VectorMask<Short>
    ShortVector.compare(VectorOperators.Comparison op, Vector<Short> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    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)
    このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。
    final ByteVector
    ByteVector.div(Vector<Byte> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final ByteVector
    ByteVector.div(Vector<Byte> v, VectorMask<Byte> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final DoubleVector
    DoubleVector.div(Vector<Double> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final DoubleVector
    DoubleVector.div(Vector<Double> v, VectorMask<Double> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final FloatVector
    FloatVector.div(Vector<Float> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final FloatVector
    FloatVector.div(Vector<Float> v, VectorMask<Float> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final IntVector
    IntVector.div(Vector<Integer> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final IntVector
    IntVector.div(Vector<Integer> v, VectorMask<Integer> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final LongVector
    LongVector.div(Vector<Long> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final LongVector
    LongVector.div(Vector<Long> v, VectorMask<Long> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final ShortVector
    ShortVector.div(Vector<Short> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final ShortVector
    ShortVector.div(Vector<Short> v, VectorMask<Short> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    abstract Vector<E>
    Vector.div(Vector<E> v)
    このベクトルを2番目の入力ベクトルで除算します。
    abstract Vector<E>
    Vector.div(Vector<E> v, VectorMask<E> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final VectorMask<Byte>
    ByteVector.eq(Vector<Byte> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.eq(Vector<Double> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.eq(Vector<Float> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.eq(Vector<Integer> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Long>
    LongVector.eq(Vector<Long> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.eq(Vector<Short> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    abstract VectorMask<E>
    Vector.eq(Vector<E> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final DoubleVector
    DoubleVector.fma(Vector<Double> b, Vector<Double> c)
    このベクトルに2番目の入力ベクトルを掛け、その結果を3番目の入力ベクトルで合計します。
    final FloatVector
    FloatVector.fma(Vector<Float> b, Vector<Float> c)
    このベクトルに2番目の入力ベクトルを掛け、その結果を3番目の入力ベクトルで合計します。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Binary op, Vector<Byte> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract ByteVector
    ByteVector.lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Binary op, Vector<Double> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract DoubleVector
    DoubleVector.lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Binary op, Vector<Float> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract FloatVector
    FloatVector.lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Binary op, Vector<Integer> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final IntVector
    IntVector.lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract IntVector
    IntVector.lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Binary op, Vector<Long> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Binary op, Vector<Long> v, VectorMask<Long> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final LongVector
    LongVector.lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract LongVector
    LongVector.lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Binary op, Vector<Short> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Binary op, Vector<Short> v, VectorMask<Short> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract ShortVector
    ShortVector.lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2, VectorMask<Short> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Binary op, Vector<E> v)
    このベクトルの対応するレーン値を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)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract Vector<E>
    Vector.lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    final VectorMask<Byte>
    ByteVector.lt(Vector<Byte> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Double>
    DoubleVector.lt(Vector<Double> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Float>
    FloatVector.lt(Vector<Float> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Integer>
    IntVector.lt(Vector<Integer> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Long>
    LongVector.lt(Vector<Long> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Short>
    ShortVector.lt(Vector<Short> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    abstract VectorMask<E>
    Vector.lt(Vector<E> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final ByteVector
    ByteVector.max(Vector<Byte> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final DoubleVector
    DoubleVector.max(Vector<Double> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final FloatVector
    FloatVector.max(Vector<Float> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final IntVector
    IntVector.max(Vector<Integer> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final LongVector
    LongVector.max(Vector<Long> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final ShortVector
    ShortVector.max(Vector<Short> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    abstract Vector<E>
    Vector.max(Vector<E> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final ByteVector
    ByteVector.min(Vector<Byte> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final DoubleVector
    DoubleVector.min(Vector<Double> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final FloatVector
    FloatVector.min(Vector<Float> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final IntVector
    IntVector.min(Vector<Integer> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final LongVector
    LongVector.min(Vector<Long> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final ShortVector
    ShortVector.min(Vector<Short> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    abstract Vector<E>
    Vector.min(Vector<E> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final ByteVector
    ByteVector.mul(Vector<Byte> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final ByteVector
    ByteVector.mul(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final DoubleVector
    DoubleVector.mul(Vector<Double> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final DoubleVector
    DoubleVector.mul(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final FloatVector
    FloatVector.mul(Vector<Float> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final FloatVector
    FloatVector.mul(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final IntVector
    IntVector.mul(Vector<Integer> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final IntVector
    IntVector.mul(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final LongVector
    LongVector.mul(Vector<Long> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final LongVector
    LongVector.mul(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final ShortVector
    ShortVector.mul(Vector<Short> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final ShortVector
    ShortVector.mul(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    abstract Vector<E>
    Vector.mul(Vector<E> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    abstract Vector<E>
    Vector.mul(Vector<E> v, VectorMask<E> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final ByteVector
    ByteVector.or(Vector<Byte> v)
    このベクトルと別の入力ベクトルのビット単位の論理和(|)を計算します。
    final IntVector
    IntVector.or(Vector<Integer> v)
    このベクトルと別の入力ベクトルのビット単位の論理和(|)を計算します。
    final LongVector
    LongVector.or(Vector<Long> v)
    このベクトルと別の入力ベクトルのビット単位の論理和(|)を計算します。
    final ShortVector
    ShortVector.or(Vector<Short> v)
    このベクトルと別の入力ベクトルのビット単位の論理和(|)を計算します。
    final DoubleVector
    DoubleVector.pow(Vector<Double> b)
    このベクトルを2番目の入力ベクトルの累乗にします。
    final FloatVector
    FloatVector.pow(Vector<Float> b)
    このベクトルを2番目の入力ベクトルの累乗にします。
    abstract ByteVector
    ByteVector.rearrange(VectorShuffle<Byte> s, Vector<Byte> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract DoubleVector
    DoubleVector.rearrange(VectorShuffle<Double> s, Vector<Double> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract FloatVector
    FloatVector.rearrange(VectorShuffle<Float> s, Vector<Float> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract IntVector
    IntVector.rearrange(VectorShuffle<Integer> s, Vector<Integer> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract LongVector
    LongVector.rearrange(VectorShuffle<Long> s, Vector<Long> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract ShortVector
    ShortVector.rearrange(VectorShuffle<Short> s, Vector<Short> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract Vector<E>
    Vector.rearrange(VectorShuffle<E> s, Vector<E> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract ByteVector
    ByteVector.selectFrom(Vector<Byte> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract ByteVector
    ByteVector.selectFrom(Vector<Byte> s, VectorMask<Byte> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract DoubleVector
    DoubleVector.selectFrom(Vector<Double> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract DoubleVector
    DoubleVector.selectFrom(Vector<Double> s, VectorMask<Double> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract FloatVector
    FloatVector.selectFrom(Vector<Float> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract FloatVector
    FloatVector.selectFrom(Vector<Float> s, VectorMask<Float> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract IntVector
    IntVector.selectFrom(Vector<Integer> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract IntVector
    IntVector.selectFrom(Vector<Integer> s, VectorMask<Integer> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract LongVector
    LongVector.selectFrom(Vector<Long> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract LongVector
    LongVector.selectFrom(Vector<Long> s, VectorMask<Long> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract ShortVector
    ShortVector.selectFrom(Vector<Short> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract ShortVector
    ShortVector.selectFrom(Vector<Short> s, VectorMask<Short> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract Vector<E>
    Vector.selectFrom(Vector<E> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract Vector<E>
    Vector.selectFrom(Vector<E> v, VectorMask<E> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract ByteVector
    ByteVector.slice(int origin, Vector<Byte> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final ByteVector
    ByteVector.slice(int origin, Vector<Byte> w, VectorMask<Byte> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract DoubleVector
    DoubleVector.slice(int origin, Vector<Double> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final DoubleVector
    DoubleVector.slice(int origin, Vector<Double> w, VectorMask<Double> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract FloatVector
    FloatVector.slice(int origin, Vector<Float> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final FloatVector
    FloatVector.slice(int origin, Vector<Float> w, VectorMask<Float> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract IntVector
    IntVector.slice(int origin, Vector<Integer> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final IntVector
    IntVector.slice(int origin, Vector<Integer> w, VectorMask<Integer> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract LongVector
    LongVector.slice(int origin, Vector<Long> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final LongVector
    LongVector.slice(int origin, Vector<Long> w, VectorMask<Long> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract ShortVector
    ShortVector.slice(int origin, Vector<Short> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final ShortVector
    ShortVector.slice(int origin, Vector<Short> w, VectorMask<Short> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract Vector<E>
    Vector.slice(int origin, Vector<E> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    abstract Vector<E>
    Vector.slice(int origin, Vector<E> v1, VectorMask<E> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final ByteVector
    ByteVector.sub(Vector<Byte> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final ByteVector
    ByteVector.sub(Vector<Byte> v, VectorMask<Byte> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final DoubleVector
    DoubleVector.sub(Vector<Double> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final DoubleVector
    DoubleVector.sub(Vector<Double> v, VectorMask<Double> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final FloatVector
    FloatVector.sub(Vector<Float> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final FloatVector
    FloatVector.sub(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final IntVector
    IntVector.sub(Vector<Integer> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final IntVector
    IntVector.sub(Vector<Integer> v, VectorMask<Integer> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final LongVector
    LongVector.sub(Vector<Long> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final LongVector
    LongVector.sub(Vector<Long> v, VectorMask<Long> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    final ShortVector
    ShortVector.sub(Vector<Short> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final ShortVector
    ShortVector.sub(Vector<Short> v, VectorMask<Short> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract Vector<E>
    Vector.sub(Vector<E> v)
    このベクトルから2番目の入力ベクトルを減算します。
    abstract Vector<E>
    Vector.sub(Vector<E> v, VectorMask<E> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract ByteVector
    ByteVector.unslice(int origin, Vector<Byte> w, int part)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    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)
    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)
    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)
    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)
    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)
    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)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract Vector<E>
    Vector.unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。