モジュール jdk.incubator.vector
パッケージ jdk.incubator.vector

クラスFloatVector

java.lang.Object
jdk.internal.vm.vector.VectorSupport.VectorPayload
jdk.internal.vm.vector.VectorSupport.Vector<E>
jdk.incubator.vector.Vector<E>
jdk.incubator.vector.FloatVector
public abstract class FloatVector extends Vector<E>
順序付けられた不変のfloat値のシーケンスを表す特殊なVector。

  • フィールドのサマリー

    フィールド
    修飾子と型
    フィールド
    説明
    static final VectorSpecies<Float>
    SPECIES_128
    VectorShape.S_128_BITのFloatVectorを表す種。
    static final VectorSpecies<Float>
    SPECIES_256
    VectorShape.S_256_BITのFloatVectorを表す種。
    static final VectorSpecies<Float>
    SPECIES_512
    VectorShape.S_512_BITのFloatVectorを表す種。
    static final VectorSpecies<Float>
    SPECIES_64
    VectorShape.S_64_BITのFloatVectorを表す種。
    static final VectorSpecies<Float>
    SPECIES_MAX
    VectorShape.S_Max_BITのFloatVectorを表す種。
    static final VectorSpecies<Float>
    SPECIES_PREFERRED
    FloatVectorの優先種。

  • メソッドのサマリー

    修飾子と型
    メソッド
    説明
    final FloatVector
    abs()
    このベクトルの絶対値を返します。
    final FloatVector
    add(float e)
    このベクトルを入力スカラーのブロードキャストに追加します。
    final FloatVector
    add(float e, VectorMask<Float> m)
    このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    add(Vector<Float> v)
    このベクトルを2番目の入力ベクトルに追加します。
    final FloatVector
    add(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract FloatVector
    addIndex(int scale)
    指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。
    final FloatVector
    blend(float e, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    final FloatVector
    blend(long e, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract FloatVector
    blend(Vector<Float> v, VectorMask<Float> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract FloatVector
    broadcast(float e)
    すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。
    abstract FloatVector
    broadcast(long e)
    すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。
    static FloatVector
    broadcast(VectorSpecies<Float> species, float e)
    すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。
    static FloatVector
    broadcast(VectorSpecies<Float> species, long e)
    すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。
    final <F> Vector<F>
    castShape(VectorSpecies<F> toSpecies, int part)
    ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。
    final <F> Vector<F>
    check(Class<F> elementType)
    このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。
    final <F> Vector<F>
    check(VectorSpecies<F> species)
    このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。
    abstract VectorMask<Float>
    compare(VectorOperators.Comparison op, float e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    compare(VectorOperators.Comparison op, long e)
    指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    compare(VectorOperators.Comparison op, long e, VectorMask<Float> m)
    指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。
    abstract VectorMask<Float>
    compare(VectorOperators.Comparison op, Vector<Float> v)
    指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。
    final VectorMask<Float>
    compare(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m)
    このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。
    final <F> Vector<F>
    convert(VectorOperators.Conversion<Float,F> conv, int part)
    指定された「変換」に従って、このベクトルを同じシェイプのベクトルおよび新しい要素タイプに変換し、レーン値を現在のETYPEから新しいレーン型の(ここではFTYPEと呼びます)に変換します。
    abstract <F> Vector<F>
    convertShape(VectorOperators.Conversion<Float,F> conv, VectorSpecies<F> rsp, int part)
    指定された「変換」に従って、このベクトルを指定された種、シェイプ、および要素型のベクトルに変換し、レーン値を現在のETYPEから新しいレーン型(ここではFTYPEと呼びます)に変換します。
    final FloatVector
    div(float e)
    このベクトルを入力スカラーのブロードキャストで除算します。
    final FloatVector
    div(float e, VectorMask<Float> m)
    このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    div(Vector<Float> v)
    このベクトルを2番目の入力ベクトルで除算します。
    final FloatVector
    div(Vector<Float> v, VectorMask<Float> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    final VectorMask<Float>
    eq(float e)
    このベクトルが入力スカラーと等しいかどうかを判定します。
    final VectorMask<Float>
    eq(Vector<Float> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    final boolean
    equals(Object obj)
    このベクトルが他のオブジェクトと同一かどうかを示します。
    final FloatVector
    fma(float b, float c)
    このベクトルにスカラー乗数を掛け、その結果をスカラー加数で合計します。
    final FloatVector
    fma(Vector<Float> b, Vector<Float> c)
    このベクトルに2番目の入力ベクトルを掛け、その結果を3番目の入力ベクトルで合計します。
    static FloatVector
    fromArray(VectorSpecies<Float> species, float[] a, int offset)
    オフセットから始まるfloat[]型の配列からベクトルをロードします。
    static FloatVector
    fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)
    「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、float[]タイプの配列から要素で構成される新しいベクトルを収集します。
    static FloatVector
    fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
    マスクの制御下にあるfloat[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    static FloatVector
    fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)
    オフセットからマスクを使用して、float[]型の配列からベクトルをロードします。
    static FloatVector
    fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo)
    オフセットから始まるバイト配列からベクトルをロードします。
    static FloatVector
    fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)
    オフセットからマスクを使用してバイト配列からベクトルをロードします。
    static FloatVector
    fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo)
    オフセットから始まるベクトルをbyte bufferからbyteバッファにロードします。
    static FloatVector
    fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)
    オフセットからbyteバッファに開始し、マスクを使用して、byte bufferからベクトルをロードします。
    final int
    hashCode()
    ベクトルのハッシュ・コード値を返します。
    final void
    intoArray(float[] a, int offset)
    このベクトルをオフセットから始まるfloat[]型の配列に格納します。
    final void
    intoArray(float[] a, int offset, int[] indexMap, int mapOffset)
    「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、このベクトルをfloat[]型の配列に分散します。
    final void
    intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
    このベクトルを、マスクの制御下にあるfloat[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。
    final void
    intoArray(float[] a, int offset, VectorMask<Float> m)
    このベクトルを、オフセットから始めてマスクを使用するfloat[]型の配列に格納します。
    final void
    intoByteArray(byte[] a, int offset, ByteOrder bo)
    明示的なバイト順序を使用して、オフセットから始まるバイト配列にこのベクトルを格納します。
    final void
    intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)
    明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。
    final void
    intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)
    明示的なバイト順序を使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。
    final void
    intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)
    明示的なバイト順序とマスクを使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。
    abstract float
    lane(int i)
    レーン索引iのレーン要素を取得
    final FloatVector
    lanewise(VectorOperators.Binary op, float e)
    このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。
    final FloatVector
    lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m)
    このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。
    final FloatVector
    lanewise(VectorOperators.Binary op, long e)
    このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。
    final FloatVector
    lanewise(VectorOperators.Binary op, long e, VectorMask<Float> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract FloatVector
    lanewise(VectorOperators.Binary op, Vector<Float> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    final FloatVector
    lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    final FloatVector
    lanewise(VectorOperators.Ternary op, float e1, float e2)
    このベクトルのレーンの値を2つのブロードキャスト・スカラーの値と結合します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)
    このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2)
    このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)
    このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。
    abstract FloatVector
    lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    final FloatVector
    lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract FloatVector
    lanewise(VectorOperators.Unary op)
    このベクトルのレーン値を操作します。
    final FloatVector
    lanewise(VectorOperators.Unary op, VectorMask<Float> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    final VectorMask<Float>
    lt(float e)
    このベクトルが入力スカラーより小さいかどうかを判定します。
    final VectorMask<Float>
    lt(Vector<Float> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    final VectorMask<Float>
    maskAll(boolean bit)
    このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。
    final FloatVector
    max(float e)
    このベクトルの大きい方と入力スカラーのブロードキャストを計算します。
    final FloatVector
    max(Vector<Float> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    final FloatVector
    min(float e)
    このベクトルの小さい方と入力スカラーのブロードキャストを計算します。
    final FloatVector
    min(Vector<Float> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    final FloatVector
    mul(float e)
    このベクトルに入力スカラーのブロードキャストを掛けます。
    final FloatVector
    mul(float e, VectorMask<Float> m)
    このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。
    final FloatVector
    mul(Vector<Float> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    final FloatVector
    mul(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    final FloatVector
    neg()
    このベクトルを否定します。
    final FloatVector
    pow(float b)
    このベクトルをスカラー累乗します。
    final FloatVector
    pow(Vector<Float> b)
    このベクトルを2番目の入力ベクトルの累乗にします。
    abstract FloatVector
    rearrange(VectorShuffle<Float> m)
    特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract FloatVector
    rearrange(VectorShuffle<Float> s, Vector<Float> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract FloatVector
    rearrange(VectorShuffle<Float> s, VectorMask<Float> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract float
    reduceLanes(VectorOperators.Associative op)
    このベクトルのすべてのレーンから累積された値を返します。
    abstract float
    reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    final ByteVector
    reinterpretAsBytes()
    このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyteでは、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。
    DoubleVector
    reinterpretAsDoubles()
    このベクトルを、同じシェイプおよび内容でレーン型のdoubleのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    FloatVector
    reinterpretAsFloats()
    このベクトルを、同じシェイプおよび内容でレーン型のfloatのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    IntVector
    reinterpretAsInts()
    このベクトルを、同じシェイプおよび内容でレーン型のintのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    LongVector
    reinterpretAsLongs()
    このベクトルを、同じシェイプおよび内容でレーン型のlongのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    ShortVector
    reinterpretAsShorts()
    このベクトルを、同じシェイプおよび内容でレーン型のshortのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract FloatVector
    selectFrom(Vector<Float> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract FloatVector
    selectFrom(Vector<Float> s, VectorMask<Float> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract FloatVector
    slice(int origin)
    現在のベクトル内の指定されたoriginレーンから始まる隣接レーンのセグメントをスライスします。
    abstract FloatVector
    slice(int origin, Vector<Float> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    final FloatVector
    slice(int origin, Vector<Float> w, VectorMask<Float> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    final VectorSpecies<Float>
    species()
    このベクトルの種を返します。
    final FloatVector
    sqrt()
    このベクトルの平方根を計算します。
    final FloatVector
    sub(float e)
    このベクトルから入力スカラーを減算します。
    final FloatVector
    sub(float e, VectorMask<Float> m)
    マスクの制御下にあるこのベクトルから入力スカラーを減算します。
    final FloatVector
    sub(Vector<Float> v)
    このベクトルから2番目の入力ベクトルを減算します。
    final FloatVector
    sub(Vector<Float> v, VectorMask<Float> m)
    マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。
    abstract VectorMask<Float>
    test(VectorOperators.Test op)
    指定された演算に従って、このベクトルのレーンをテストします。
    final VectorMask<Float>
    test(VectorOperators.Test op, VectorMask<Float> m)
    指定された演算に従って、このベクトルの選択されたレーンをテストします。
    final float[]
    toArray()
    すべてのレーン値を含むfloat[]型の配列を返します。
    final double[]
    toDoubleArray()
    double型に変換された、すべてのレーン値を含むdouble[]配列を返します。
    final int[]
    toIntArray()
    int型に変換された、すべてのレーン値を含むint[]配列を返します。
    final long[]
    toLongArray()
    long型に変換された、すべてのレーン値を含むlong[]配列を返します。
    final String
    toString()
    このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"形式のこのベクトルの文字列表現を返します。
    abstract FloatVector
    unslice(int origin)
    slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。
    abstract FloatVector
    unslice(int origin, Vector<Float> w, int part)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract FloatVector
    unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    final FloatVector
    viewAsFloatingLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。
    final IntVector
    viewAsIntegralLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。
    abstract FloatVector
    withLane(int i, float e)
    レーン索引iにあるこのベクトルのレーン要素を値eに置き換えます。
    static FloatVector
    zero(VectorSpecies<Float> species)
    すべてのレーン要素がデフォルトのプリミティブ値であるゼロに設定されている、指定された種のベクトルを返します。

    クラスjdk.incubator.vector.Vectorで宣言されたメソッド

    bitSize, byteSize, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle

    クラスjdk.internal.vm.vector.VectorSupport.VectorPayloadで宣言されたメソッド

    getPayload

    クラス java.lang.Objectで宣言されたメソッド

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

  • フィールド詳細

  • メソッドの詳細

    • zero

      public static FloatVector zero(VectorSpecies<Float> species)
      すべてのレーン要素がデフォルトのプリミティブ値であるゼロに設定されている、指定された種のベクトルを返します。
      パラメータ:
      species - 目的のゼロ・ベクトルの種
      戻り値:
      ゼロ・ベクトル

    • broadcast

      public abstract FloatVector broadcast(float e)
      すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。 現在のベクトルの内容は破棄されます。この演算に関連するのは種だけです。

      このメソッドは、この式の値を戻します: FloatVector.broadcast(this.species(), e)。

      APIのノート:
      スーパータイプVectorのbroadcast()という名前の同様のメソッドとは異なり、このメソッドはその引数を検証する必要はなく、IllegalArgumentExceptionをスローできません。 したがって、このメソッドはスーパータイプ・メソッドよりも推奨されます。
      パラメータ:
      e - ブロードキャストする値
      戻り値:
      すべてのレーン要素がプリミティブ値eに設定されているベクトル
      関連項目:

    • broadcast

      public static FloatVector broadcast(VectorSpecies<Float> species, float e)
      すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。
      パラメータ:
      species - 希望するベクトルの種
      e - ブロードキャストする値
      戻り値:
      すべてのレーン要素がプリミティブ値eに設定されているベクトル
      関連項目:

    • broadcast

      public abstract FloatVector broadcast(long e)
      すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。 現在のベクトルの内容は破棄されます。この演算に関連するのは種だけです。

      このメソッドは、この式の値を戻します: EVector.broadcast(this.species(), (ETYPE)e)。EVectorは、このベクトル要素タイプETYPEに固有のベクトル・クラスです。

      e==(long)(ETYPE)eになるように、long値eは、このベクトル種のETYPEによって正確に表現可能である必要があります。 このルールに違反すると、問題は静的に検出されませんが、実行時にIllegalArgumentExceptionがスローされます。 したがって、このメソッドは、直接の定数およびその他のスカラーの静的な型チェックを若干弱めますが、汎用APIの表現性を向上させることでこれを実現します。 すべてのETYPEはすべてのbyte値を受け入れるため、[-128..127]の範囲内のe値は常に受け入れられます。

      定義:
      クラスVector<Float>のbroadcast
      APIのノート:
      FloatVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.broadcast((float)e)。 この2つの式は、数値的に同一の結果を生成します。
      パラメータ:
      e - ブロードキャストする値
      戻り値:
      すべてのレーン要素がプリミティブ値eに設定されているベクトル
      関連項目:

    • broadcast

      public static FloatVector broadcast(VectorSpecies<Float> species, long e)
      すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。 long値は、e==(long)(ETYPE)eのようにベクトル種のETYPEで正確に表現できる必要があります。
      パラメータ:
      species - 希望するベクトルの種
      e - ブロードキャストする値
      戻り値:
      すべてのレーン要素がプリミティブ値eに設定されているベクトル
      例外:
      IllegalArgumentException - 指定されたlong値をベクトルETYPEで表現できない場合
      関連項目:

    • lanewise

      public abstract FloatVector lanewise(VectorOperators.Unary op)
      このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値の処理に使用される演算
      戻り値:
      入力ベクトルにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Unary op, VectorMask<Float> m)
      マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値の処理に使用される演算
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public abstract FloatVector lanewise(VectorOperators.Binary op, Vector<Float> v)
      このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値を結合するために使用される演算
      v - 入力ベクトル
      戻り値:
      2つの入力ベクトルにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)
      このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値を結合するために使用される演算
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      2つの入力ベクトルにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Binary op, float e)
      このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e))。
      パラメータ:
      op - レーン値の処理に使用される演算
      e - 入力スカラー
      戻り値:
      2つの入力ベクトルにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m)
      このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e), m)。
      パラメータ:
      op - レーン値の処理に使用される演算
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルとスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Binary op, long e)
      このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e))。
      定義:
      クラスVector<Float>のlanewise
      APIのノート:
      FloatVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.lanewise(op,(float)e)。 この2つの式は、数値的に同一の結果を生成します。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e - 入力スカラー
      戻り値:
      入力ベクトルとスカラーにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Binary op, long e, VectorMask<Float> m)
      このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 2番目のオペランドはブロードキャスト整数値です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e), m)。
      定義:
      クラスVector<Float>のlanewise
      APIのノート:
      FloatVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.lanewise(op,(float)e,m)。 この2つの式は、数値的に同一の結果を生成します。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルとスカラーにレーンワイズ演算を適用した結果
      関連項目:

    • lanewise

      public abstract FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2)
      このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。 これは、選択した演算を各レーンに適用するレーンワイズの三項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値を結合するために使用される演算
      v1 - 2番目の入力ベクトル
      v2 - 3番目の入力ベクトル
      戻り値:
      3つの入力ベクトルに演算レーンワイズを適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)
      このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。
      定義:
      クラスVector<Float>のlanewise
      パラメータ:
      op - レーン値を結合するために使用される演算
      v1 - 2番目の入力ベクトル
      v2 - 3番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      3つの入力ベクトルに演算レーンワイズを適用した結果
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, float e1, float e2)
      このベクトルのレーンの値を2つのブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), this.broadcast(e2))。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e1 - 最初の入力スカラー
      e2 - 2番目の入力スカラー
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)
      このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e1 - 最初の入力スカラー
      e2 - 2番目の入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2)
      このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, v1, this.broadcast(e2))。
      パラメータ:
      op - レーン値を結合するために使用される演算
      v1 - その他の入力ベクトル
      e2 - 入力スカラー
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)
      このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, v1, this.broadcast(e2), m)。
      パラメータ:
      op - レーン値を結合するために使用される演算
      v1 - その他の入力ベクトル
      e2 - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)
      このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), v2)。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e1 - 入力スカラー
      v2 - その他の入力ベクトル
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public final FloatVector lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)
      このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), v2, m)。
      パラメータ:
      op - レーン値を結合するために使用される演算
      e1 - 入力スカラー
      v2 - その他の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • add

      public final FloatVector add(Vector<Float> v)
      このベクトルを2番目の入力ベクトルに追加します。 これは、プリミティブ加算演算(+)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( ADD, v)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のadd
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルを2番目の入力ベクトルに加算した結果
      関連項目:

    • add

      public final FloatVector add(float e)
      このベクトルを入力スカラーのブロードキャストに追加します。 これは、プリミティブ加算演算(+)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( ADD, e)とも同じです。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルの各レーンをスカラーに加算した結果
      関連項目:

    • add

      public final FloatVector add(Vector<Float> v, VectorMask<Float> m)
      マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。 これは、対応するレーン値の各ペアにプリミティブ加算演算(+)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise( ADD, v, m)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のadd
      パラメータ:
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      指定されたベクトルにこのベクトルを追加した結果
      関連項目:

    • add

      public final FloatVector add(float e, VectorMask<Float> m)
      このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。 これは、各レーンにプリミティブ加算演算(+)を適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( ADD, s, m)とも同じです。
      パラメータ:
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      このベクトルの各レーンをスカラーに加算した結果
      関連項目:

    • sub

      public final FloatVector sub(Vector<Float> v)
      このベクトルから2番目の入力ベクトルを減算します。 これは、プリミティブ減算演算(-)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( SUB, v)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のsub
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルから2番目の入力ベクトルを減算した結果
      関連項目:

    • sub

      public final FloatVector sub(float e)
      このベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( SUB, e)とも同じです。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルの各レーンからスカラーを減算した結果
      関連項目:

    • sub

      public final FloatVector sub(Vector<Float> v, VectorMask<Float> m)
      マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。 これは、対応するレーン値の各ペアにプリミティブ減算演算(-)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise( SUB, v, m)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のsub
      パラメータ:
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      このベクトルから2番目の入力ベクトルを減算した結果
      関連項目:

    • sub

      public final FloatVector sub(float e, VectorMask<Float> m)
      マスクの制御下にあるこのベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( SUB, s, m)とも同じです。
      パラメータ:
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      このベクトルの各レーンからスカラーを減算した結果
      関連項目:

    • mul

      public final FloatVector mul(Vector<Float> v)
      このベクトルに2番目の入力ベクトルを掛けます。 これは、プリミティブ乗算演算(*)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MUL, v)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のmul
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルに2番目の入力ベクトルを掛けた結果
      関連項目:

    • mul

      public final FloatVector mul(float e)
      このベクトルに入力スカラーのブロードキャストを掛けます。 これは、プリミティブ乗算演算(*)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MUL, e)とも同じです。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルに指定されたスカラーを掛けた結果
      関連項目:

    • mul

      public final FloatVector mul(Vector<Float> v, VectorMask<Float> m)
      マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。 これは、プリミティブ乗算演算(*)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise( MUL, v, m)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のmul
      パラメータ:
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      このベクトルに指定されたベクトルを掛けた結果
      関連項目:

    • mul

      public final FloatVector mul(float e, VectorMask<Float> m)
      このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ乗算演算(*)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( MUL, s, m)とも同じです。
      パラメータ:
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      このベクトルの各レーンをスカラーに殺した結果
      関連項目:

    • div

      public final FloatVector div(Vector<Float> v)
      このベクトルを2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( DIV, v)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のdiv
      APIのノート:
      基本となるスカラー演算子はIEEE浮動小数点数であるため、実際にゼロ除算しても例外はスローされませんが、符号付きの無限大またはNaNが生成されます。
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルを2番目の入力ベクトルで割った結果
      関連項目:

    • div

      public final FloatVector div(float e)
      このベクトルを入力スカラーのブロードキャストで除算します。 これは、プリミティブ分割演算(/)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( DIV, e)とも同じです。
      APIのノート:
      基本となるスカラー演算子はIEEE浮動小数点数であるため、実際にゼロ除算しても例外はスローされませんが、符号付きの無限大またはNaNが生成されます。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルの各レーンをスカラーで割った結果
      関連項目:

    • div

      public final FloatVector div(Vector<Float> v, VectorMask<Float> m)
      このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise( DIV, v, m)とも同じです。

      フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。

      定義:
      クラスVector<Float>のdiv
      APIのノート:
      基本となるスカラー演算子はIEEE浮動小数点数であるため、実際にゼロ除算しても例外はスローされませんが、符号付きの無限大またはNaNが生成されます。
      パラメータ:
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      このベクトルを2番目の入力ベクトルで割った結果
      関連項目:

    • div

      public final FloatVector div(float e, VectorMask<Float> m)
      このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ分割演算(/)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( DIV, s, m)とも同じです。
      APIのノート:
      基本となるスカラー演算子はIEEE浮動小数点数であるため、実際にゼロ除算しても例外はスローされませんが、符号付きの無限大またはNaNが生成されます。
      パラメータ:
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      このベクトルの各レーンをスカラーで割った結果
      関連項目:

    • min

      public final FloatVector min(Vector<Float> v)
      このベクトルと2番目の入力ベクトルの小さい方を計算します。 これは、演算Math.min()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MIN, v)とも同じです。
      定義:
      クラスVector<Float>のmin
      APIのノート:
      このメソッドでは、浮動小数点の負のゼロ-0.0は、デフォルト値の(正のゼロ)とは異なる値として扱われます。
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルと2番目の入力ベクトルのレーン最小値
      関連項目:

    • min

      public final FloatVector min(float e)
      このベクトルの小さい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.min()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MIN, e)とも同じです。
      APIのノート:
      このメソッドでは、浮動小数点の負のゼロ-0.0は、デフォルト値の(正のゼロ)とは異なる値として扱われます。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルに指定されたスカラーを掛けた結果
      関連項目:

    • max

      public final FloatVector max(Vector<Float> v)
      このベクトルと2番目の入力ベクトルの大きい方を計算します。 これは、演算Math.max()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MAX, v)とも同じです。

      これは、add()のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewiseを介して取得できます。 サブクラスは、このメソッドの追加のスカラー・ブロードキャスト・オーバーロードを定義します。

      定義:
      クラスVector<Float>のmax
      APIのノート:
      このメソッドでは、浮動小数点の負のゼロ-0.0は、デフォルト値の(正のゼロ)とは異なる値として扱われます。
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルと2番目の入力ベクトルのレーン方向の最大値
      関連項目:

    • max

      public final FloatVector max(float e)
      このベクトルの大きい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.max()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MAX, e)とも同じです。
      APIのノート:
      このメソッドでは、浮動小数点の負のゼロ-0.0は、デフォルト値の(正のゼロ)とは異なる値として扱われます。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルに指定されたスカラーを掛けた結果
      関連項目:

    • pow

      public final FloatVector pow(Vector<Float> b)
      このベクトルを2番目の入力ベクトルの累乗にします。 これは、Math.pow(a,b)の仕様に準拠する演算を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 この演算は、オペランドと結果をキャストするように調整されます。具体的には、floatオペランドをdoubleオペランドに拡大し、double結果をfloat結果に絞り込みます。 このメソッドは、式lanewise( POW, b)とも同じです。

      これは、addのようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewiseを介して取得できます。

      パラメータ:
      b - このベクトルを累乗するベクトル指数
      戻り値:
      このベクトルのb-th乗
      関連項目:

    • pow

      public final FloatVector pow(float b)
      このベクトルをスカラー累乗します。 これは、Math.pow(a,b)の仕様に準拠する演算を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 この演算は、オペランドと結果をキャストするように調整されます。具体的には、floatオペランドをdoubleオペランドに拡大し、double結果をfloat結果に絞り込みます。 このメソッドは、式lanewise( POW, b)とも同じです。
      パラメータ:
      b - このベクトルを累乗するスカラー指数
      戻り値:
      このベクトルのb-th乗
      関連項目:

    • neg

      public final FloatVector neg()
      このベクトルを否定します。 これは、プリミティブ否定演算(-x)を各入力レーンに適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( NEG)とも同じです。
      定義:
      クラスVector<Float>のneg
      戻り値:
      このベクトルの否定
      関連項目:

    • abs

      public final FloatVector abs()
      このベクトルの絶対値を返します。 これは、各入力レーンにメソッドMath.absを適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( ABS)とも同じです。
      定義:
      クラスVector<Float>のabs
      戻り値:
      このベクトルの絶対値
      関連項目:

    • sqrt

      public final FloatVector sqrt()
      このベクトルの平方根を計算します。 これは、Math.sqrt(a)の仕様に準拠する演算を各レーン値に適用するレーンワイズ単項演算です。 演算はオペランドと結果をキャストするように調整されます。具体的には、floatオペランドをdoubleオペランドに拡大し、double結果をfloat結果に絞り込みます。 このメソッドは、式lanewise( SQRT)とも同じです。
      戻り値:
      このベクトルの平方根
      関連項目:

    • eq

      public final VectorMask<Float> eq(Vector<Float> v)
      このベクトルが別の入力ベクトルと等しいかどうかを判定します。 これは、プリミティブ等価演算(==)を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.EQ, v)と同じです。
      定義:
      クラスVector<Float>のeq
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルが2番目の入力ベクトルと等しいかどうかをレーンワイズ判定した結果のマスク
      関連項目:

    • eq

      public final VectorMask<Float> eq(float e)
      このベクトルが入力スカラーと等しいかどうかを判定します。 これは、プリミティブ等価演算(==)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.Comparison.EQ, e)と同じです。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルがeと等しいかどうかを判定する結果マスク
      関連項目:

    • lt

      public final VectorMask<Float> lt(Vector<Float> v)
      このベクトルが別の入力ベクトルより小さいかどうかを判定します。 これは、プリミティブなより小さい演算の(<)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.LT, v)と同じです。
      定義:
      クラスVector<Float>のlt
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルが2番目の入力ベクトルより小さい場合のレーンワイズ・テストのマスク結果
      関連項目:

    • lt

      public final VectorMask<Float> lt(float e)
      このベクトルが入力スカラーより小さいかどうかを判定します。 これはレーンワイズ二項テスト演算で、(<)より小さいプリミティブを各レーンに適用します。 結果はcompare(VectorOperators.LT, e)と同じです。
      パラメータ:
      e - 入力スカラー
      戻り値:
      このベクトルが入力スカラーより小さいかどうかを判定したマスク結果
      関連項目:

    • test

      public abstract VectorMask<Float> test(VectorOperators.Test op)
      指定された演算に従って、このベクトルのレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用するレーンワイズ単項テスト演算です。
      定義:
      クラスVector<Float>のtest
      パラメータ:
      op - レーン値のテストに使用される演算
      戻り値:
      選択されたテスト演算子に従って、このベクトルのレーンをテストしたマスク結果
      関連項目:

    • test

      public final VectorMask<Float> test(VectorOperators.Test op, VectorMask<Float> m)
      指定された演算に従って、このベクトルの選択されたレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用する、マスクされたレーンワイズ単項テスト演算です。 返される結果は、式test(op).and(m)と同じです。
      定義:
      クラスVector<Float>のtest
      パラメータ:
      op - レーン値のテストに使用される演算
      m - マスク制御レーンの選択
      戻り値:
      選択されたテスト演算子に従って、マスクによって選択されたレーン内でのみ、このベクトルのレーンをテストしたマスク結果
      関連項目:

    • compare

      public abstract VectorMask<Float> compare(VectorOperators.Comparison op, Vector<Float> v)
      指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。
      定義:
      クラスVector<Float>のcompare
      パラメータ:
      op - レーン値の比較に使用される演算
      v - 2番目の入力ベクトル
      戻り値:
      選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
      関連項目:

    • compare

      public final VectorMask<Float> compare(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m)
      このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,v).and(m)と同じです。
      定義:
      クラスVector<Float>のcompare
      パラメータ:
      op - レーン値の比較に使用される演算
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
      関連項目:

    • compare

      public abstract VectorMask<Float> compare(VectorOperators.Comparison op, float e)
      指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、比較演算を各レーンに適用するレーンワイズ二項テスト演算です。

      結果はcompare(op, broadcast(species(), e))と同じです。 つまり、スカラーは、同じ種のベクトルにブロードキャストされたとみなされ、選択された比較演算を使用して元のベクトルと比較されます。

      パラメータ:
      op - レーン値の比較に使用される演算
      e - 入力スカラー
      戻り値:
      選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
      関連項目:

    • compare

      public final VectorMask<Float> compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)
      指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、対応するレーン値の各ペアに適用される、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,s).and(m)と同じです。
      パラメータ:
      op - レーン値の比較に使用される演算
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
      関連項目:

    • compare

      public abstract VectorMask<Float> compare(VectorOperators.Comparison op, long e)
      指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、ブロードキャスト値とペアになっている各レーン値に特定の比較演算を適用するレーンワイズ二項テスト演算です。

      結果はthis.compare(op, this.broadcast(e))と同じです。 つまり、スカラーは、同じ種のベクトルにブロードキャストされたとみなされ、選択された比較演算を使用して元のベクトルと比較されます。

      定義:
      クラスVector<Float>のcompare
      パラメータ:
      op - レーン値の比較に使用される演算
      e - 入力スカラー
      戻り値:
      選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
      関連項目:

    • compare

      public final VectorMask<Float> compare(VectorOperators.Comparison op, long e, VectorMask<Float> m)
      指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、指定された比較演算をブロードキャスト値とペアにして各レーン値に適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,e).and(m)と同じです。
      定義:
      クラスVector<Float>のcompare
      パラメータ:
      op - レーン値の比較に使用される演算
      e - 入力スカラー
      m - マスク制御レーンの選択
      戻り値:
      選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
      関連項目:

    • blend

      public abstract FloatVector blend(Vector<Float> v, VectorMask<Float> m)
      このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。
      • マスク内のレーンsetでは、新しいレーン値が2番目の入力ベクトルから取得され、このベクトルのそのレーンにあった値が置き換えられます。
      • マスク内のレーンunsetの場合、置換は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。
      次の疑似コードは、この動作を示しています: 
      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 Vector<E> b = ...;
 b.check(species);
 VectorMask<E> m = ...;
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     if (m.laneIsSet(i)) {
         ar[i] = b.lane(i);
     }
 }
 return EVector.fromArray(s, ar, 0);
      定義:
      クラスVector<Float>のblend
      パラメータ:
      v - 置換レーン値を含む2番目の入力ベクトル
      m - 2番目の入力ベクトルからのマスク制御レーンの選択
      戻り値:
      このベクトルのレーン要素を2番目の入力ベクトルのレーン要素とブレンドした結果

    • addIndex

      public abstract FloatVector addIndex(int scale)
      指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。 これはレーンワイズ単項演算で、レーンNごとにスケーリングされた索引値N*scaleを計算し、現在のベクトルのレーンNにすでに存在する値に追加します。

      結果がベクトル・レーン型のETYPEを使用して表される場合、スケールはあまり大きくしないでください。また、要素サイズは小さくしないで、N*scaleまたはVLENGTH*scaleの計算時にオーバーフローが発生します。

      次の疑似コードは、この動作を示しています: 

      
 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     long d = (long)i * scale;
     if (d != (ETYPE) d)  throw ...;
     ar[i] += (ETYPE) d;
 }
 long d = (long)ar.length * scale;
 if (d != (ETYPE) d)  throw ...;
 return EVector.fromArray(s, ar, 0);

      定義:
      クラスVector<Float>のaddIndex
      パラメータ:
      scale - 各レーン索引Nで乗算する数(通常は1)
      戻り値:
      scaleによってスケーリングされた、各レーン要素を対応するレーン索引Nで増分した結果

    • blend

      public final FloatVector blend(float e, VectorMask<Float> m)
      このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)と同じです。
      パラメータ:
      e - 置換レーン値を含む入力スカラー
      m - スカラーのマスク制御レーンの選択
      戻り値:
      このベクトルのレーン要素をスカラー値とブレンドした結果

    • blend

      public final FloatVector blend(long e, VectorMask<Float> m)
      このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)と同じです。
      定義:
      クラスVector<Float>のblend
      パラメータ:
      e - 置換レーン値を含む入力スカラー
      m - スカラーのマスク制御レーンの選択
      戻り値:
      このベクトルのレーン要素をスカラー値とブレンドした結果

    • slice

      public abstract FloatVector slice(int origin, Vector<Float> v1)
      現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。 VLENGTHレーンのブロックが独自のベクトルに抽出され、返されます。

      これは、レーン要素を現在のベクトルと2番目のベクトルの間で正面に移動するクロス・レーン演算です。 どちらのベクトルも、スライスの抽出元となる長さ2*VLENGTHの結合"background"として表示できます。 出力ベクトル内のレーン番号付きNは、入力ベクトルのレーンorigin+N(そのレーンが存在する場合)または第2ベクトル(存在することが保証されています)のレーンorigin+N-VLENGTHからコピーされます。

      origin値は、包括的な範囲の0..VLENGTHにする必要があります。 制限事項として、v.slice(0,w)およびv.slice(VLENGTH,w)は、それぞれvおよびwを返します。

      パラメータ:
      origin - スライスに転送する最初の入力レーン
      v1 - スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトル
      戻り値:
      指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得されたVLENGTHレーンの連続するスライス
      関連項目:

    • slice

      public final FloatVector slice(int origin, Vector<Float> w, VectorMask<Float> m)
      マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。 VLENGTHレーンのブロックが独自のベクトルに抽出され、返されます。 結果のベクトルは、指定されたマスクで設定されていないすべてのレーンでゼロになります。 マスクに設定されたレーンには、thisまたはv1の選択したレーンからコピーされたデータが含まれます。

      これは、レーン要素を現在のベクトルと2番目のベクトルの間で正面に移動するクロス・レーン演算です。 どちらのベクトルも、スライスの抽出元となる長さ2*VLENGTHの結合"background"として表示できます。 返される結果は、式broadcast(0).blend(slice(origin,v1),m)と同じです。

      定義:
      クラスVector<Float>のslice
      パラメータ:
      origin - スライスに転送する最初の入力レーン
      w - スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトル
      m - 結果のベクトルへのマスク制御レーンの選択
      戻り値:
      指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得されたVLENGTHレーンの連続するスライス
      関連項目:

    • slice

      public abstract FloatVector slice(int origin)
      現在のベクトル内の指定されたoriginレーンから始まる隣接レーンのセグメントをスライスします。 VLENGTHレーンのブロック(おそらくゼロのレーンが埋め込まれている)は、独自のベクトルに抽出されて返されます。 これは、ゼロ・レーンの拡張バックグラウンドに対して単一ベクトルからスライスする便利なメソッドです。 これは、slice (origin, broadcast(0))と同等です。 また、単に、ベクトルの終点にゼロが必要なレーンを埋めて、後のレーンから前のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はoriginです。
      パラメータ:
      origin - スライスに転送する最初の入力レーン
      戻り値:
      出力の最初のレーンから始まり、末尾にゼロが埋め込まれた最後のVLENGTH-origin入力レーン
      関連項目:

    • unslice

      public abstract FloatVector unslice(int origin, Vector<Float> w, int part)
      slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。

      これは、現在のベクトルのレーン要素を後方に向けるクロス・レーン演算で、バックグラウンド・ベクトルの論理ペアに挿入します。 ただし、いずれかのペアのみが返されます。 バックグラウンドは、2番目の入力ベクトルを複製することによって形成されます。 (ただし、出力に同じ入力レーンからの2つの重複が含まれることはありません。) 入力ベクトル内のレーン番号付きNは、最初のバックグラウンド・ベクトルが存在する場合はそのレーンorigin+Nにコピーされ、それ以外の場合は2番目のバックグラウンド・ベクトル(存在することが保証されています)のレーンorigin+N-VLENGTHにコピーされます。 挿入されたスライスで更新された最初または2番目のバックグラウンド・ベクトルが返されます。 partの数値がゼロまたは1の場合は、最初または2番目に更新されたバックグラウンド・ベクトルが選択されます。

      origin値は、包括的な範囲の0..VLENGTHにする必要があります。 制限事項として、v.unslice(0,w,0)とv.unslice(VLENGTH,w,1)はどちらもvを返しますが、v.unslice(0,w,1)とv.unslice(VLENGTH,w,0)は両方ともwを返します。

      定義:
      クラスVector<Float>のunslice
      パラメータ:
      origin - スライスを受け取る最初の出力レーン
      w - (2つのコピーとして)が挿入されたスライスを受け取るバックグラウンド・ベクトル
      part - 結果(ゼロまたは1つ)のパート番号
      戻り値:
      指定された原点にこのベクトルを挿入して更新された、バックグラウンド・ベクトルのペアwの最初または2番目の部分
      関連項目:

    • unslice

      public abstract FloatVector unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m)
      slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。

      これは、現在のベクトルのレーン要素を前方に通し、そのレーン(マスクによって選択された場合)をバックグラウンド・ベクトルの論理ペアに挿入するクロス・レーン演算です。 このメソッドの「マスクされていないバージョン」と同様に、part番号で選択されたペアのいずれか一方のみが返されます。 マスクによって選択されたレーンNごとに、レーン値が最初のバックグラウンド・ベクトルのレーンorigin+Nにコピーされます(そのレーンが存在する場合)。それ以外の場合は、2番目のバックグラウンド・ベクトル(存在することが保証されています)のレーンorigin+N-VLENGTHにコピーされます。 対応する入力レーンNがマスクで設定解除されている場合、バックグラウンド・レーンは元の値を保持します。 挿入されたスライスのセット・レーンで更新された最初または2番目のバックグラウンド・ベクトルが返されます。 partの数値がゼロまたは1の場合は、最初または2番目に更新されたバックグラウンド・ベクトルが選択されます。

      定義:
      クラスVector<Float>のunslice
      パラメータ:
      origin - スライスを受け取る最初の出力レーン
      w - 挿入されたスライスがmで設定されている場合に、(2つのコピーとして)が受け取るバックグラウンド・ベクトル
      part - 結果(ゼロまたは1つ)のパート番号
      m - 現在のベクトルからのマスク制御レーンの選択
      戻り値:
      指定された原点にこのベクトルの選択されたレーンを挿入することで更新された、バックグラウンド・ベクトルのペアwの最初または2番目の部分
      関連項目:

    • unslice

      public abstract FloatVector unslice(int origin)
      slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。 他のunslice()メソッドと比較して、このメソッドはバックグラウンド・ベクトルのペアの最初のメソッドのみを返します。 これは、unslice (origin, broadcast(0), 0)の結果を返す簡易メソッドです。 また、単に、ベクトルの始点で必要なレーンがゼロで塗りつぶされた、前のレーンから後のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はoriginです。
      定義:
      クラスVector<Float>のunslice
      パラメータ:
      origin - スライスを受け取る最初の出力レーン
      戻り値:
      指定された原点から始まり、先頭にゼロが埋め込まれた最初のVLENGTH-origin入力レーン
      関連項目:

    • rearrange

      public abstract FloatVector rearrange(VectorShuffle<Float> m)
      特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。 これは、このベクトルのレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンNごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)ごとに、出力レーンNはレーンIの入力ベクトルから値を取得します。
      定義:
      クラスVector<Float>のrearrange
      パラメータ:
      m - シャッフル・コント・ローリング・レーン索引の選択
      戻り値:
      このベクトルのレーン要素の再配置
      関連項目:

    • rearrange

      public abstract FloatVector rearrange(VectorShuffle<Float> s, VectorMask<Float> m)
      特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。 これは、このベクトルのレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンNごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)ごとに、出力レーンNは、マスクが設定されている場合はレーンIの入力ベクトルから値を取得します。 それ以外の場合、出力レーンNはゼロに設定されます。

      このメソッドは、この擬似コードの値を返します: 

      
 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);

      定義:
      クラスVector<Float>のrearrange
      パラメータ:
      s - シャッフル・コント・ローリング・レーン索引の選択
      m - シャッフルの適用を制御するマスク
      戻り値:
      このベクトルのレーン要素の再配置
      関連項目:

    • rearrange

      public abstract FloatVector rearrange(VectorShuffle<Float> s, Vector<Float> v)
      特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。 これは、入力ベクトル(現在のベクトルともう一方のベクトルv)のレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンNごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)ごとに、出力レーンNは、I>=0の場合はレーンIの最初のベクトルから値を取得します。 それ以外の場合、例外的な索引Iは、VLENGTHを追加することでラップされ、索引I+VLENGTHでsecondベクトルの索引付けに使用されます。

      このメソッドは、この擬似コードの値を返します: 

      
 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // or else: r1 = this.rearrange(s, s.laneIsValid());
 Vector<E> r2 = v.rearrange(s.wrapIndexes());
 return r2.blend(r1,s.laneIsValid());

      定義:
      クラスVector<Float>のrearrange
      パラメータ:
      s - 両方の入力ベクトルからのシャッフル制御レーンの選択
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルと2番目の入力ベクトルのレーン要素の再配置
      関連項目:

    • selectFrom

      public abstract FloatVector selectFrom(Vector<Float> v)
      このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 これは、このベクトルの制御下で引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 このベクトルのレーンNごと、およびこのベクトルのレーン値I=this.lane(N)ごとに、出力レーンNはレーンIの引数ベクトルから値を取得します。 このようにすると、結果には引数ベクトルvに格納されている値のみが含まれますが、thisの索引値に依存する順序で表示されます。 結果は、式v.rearrange(this.toShuffle())と同じです。
      定義:
      クラスVector<Float>のselectFrom
      パラメータ:
      v - 結果値を提供するベクトル
      戻り値:
      vのレーン要素の再配置
      関連項目:

    • selectFrom

      public abstract FloatVector selectFrom(Vector<Float> s, VectorMask<Float> m)
      このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。 このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 マスクで設定されていないレーンは、表からの値ではなくゼロを受け取ります。 これは、このベクトルとマスクの制御下で、引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 結果は、式v.rearrange(this.toShuffle(), m)と同じです。
      定義:
      クラスVector<Float>のselectFrom
      パラメータ:
      s - 結果値を提供するベクトル
      m - vからの選択を制御するマスク
      戻り値:
      vのレーン要素の再配置
      関連項目:

    • fma

      public final FloatVector fma(Vector<Float> b, Vector<Float> c)
      このベクトルに2番目の入力ベクトルを掛け、その結果を3番目の入力ベクトルで合計します。 中間結果には拡張精度が使用されるため、2つの演算ごとに1回の丸めで精度が失われる可能性がなくなります。 結果はthis.mul(b).add(c)に数値的に近いため、通常は真の数学的結果に近くなります。 これは、Math.fma(a,b,c)の仕様に準拠する演算を各レーンに適用するレーンワイズの三項演算です。 この演算は、オペランドと結果をキャストするように調整されます。具体的には、floatオペランドをdoubleオペランドに拡大し、double結果をfloat結果に絞り込みます。 このメソッドは、式lanewise( FMA, b, c)とも同じです。
      パラメータ:
      b - 乗数値を指定する2番目の入力ベクトル
      c - 3番目の入力ベクトル。追加の入力ベクトル値を指定
      戻り値:
      このベクトルと、中間結果の拡張精度を使用して3番目の入力ベクトルと合計された2番目の入力ベクトルの積
      関連項目:

    • fma

      public final FloatVector fma(float b, float c)
      このベクトルにスカラー乗数を掛け、その結果をスカラー加数で合計します。 中間結果には拡張精度が使用されるため、2つの演算ごとに1回の丸めで精度が失われる可能性がなくなります。 結果はthis.mul(b).add(c)に数値的に近いため、通常は真の数学的結果に近くなります。 これは、Math.fma(a,b,c)の仕様に準拠する演算を各レーンに適用するレーンワイズの三項演算です。 この演算は、オペランドと結果をキャストするように調整されます。具体的には、floatオペランドをdoubleオペランドに拡大し、double結果をfloat結果に絞り込みます。 このメソッドは、式lanewise( FMA, b, c)とも同じです。
      パラメータ:
      b - スカラー乗数
      c - スカラー加数
      戻り値:
      中間結果の拡張精度を使用して、このベクトルとスカラー乗数の積にスカラー加数を加算したもの
      関連項目:

    • reduceLanes

      public abstract float reduceLanes(VectorOperators.Associative op)
      このベクトルのすべてのレーンから累積された値を返します。 これは、指定された演算をすべてのレーン要素に適用する、関連するクロス・レーン削減演算です。

      いくつかのリダクション演算はオペランドの任意の並替えをサポートしていませんが、有用性のためにここに含まれています。

      • FIRST_NONZEROの場合、リダクションは最小番号のゼロ以外のレーンから値を返します。 (MAXおよびMINと同様に、浮動小数点の負のゼロ-0.0は、デフォルト値である正のゼロとは異なる値として扱われます。 そのため、ゼロ以外のレーン値が存在する場合でも、最初のノズロのレーン削減によって-0.0が返される可能性があります。)
      • ADDおよびMULの場合、正確な結果には任意の演算順序の選択が反映され、時間の経過とともに変化することもあります。 詳細は、「浮動小数点ベクトルに対する演算」の項を参照してください。
      • その他のリダクション演算はすべて、完全に可換的であり、連想的です。 実装では任意の処理順序を選択できますが、常に同じ結果が生成されます。

      パラメータ:
      op - レーン値を結合するために使用される演算
      戻り値:
      累積結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • reduceLanes

      public abstract float reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)
      マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。 これは、指定した工程を選択したレーン要素に適用する、関連するクロス・レーン短縮演算です。

      要素が選択されていない場合は、演算固有のアイデンティティ値が返されます。

      • 演算がADDまたはFIRST_NONZEROの場合、アイデンティティ値はデフォルトのfloat値である正のゼロです。
      • 演算がMULの場合、アイデンティティ値はいずれかです。
      • 演算がMAXの場合、アイデンティティ値はFloat.NEGATIVE_INFINITYです。
      • 演算がMINの場合、アイデンティティ値はFloat.POSITIVE_INFINITYです。

      いくつかのリダクション演算はオペランドの任意の並替えをサポートしていませんが、有用性のためにここに含まれています。

      • FIRST_NONZEROの場合、リダクションは最小番号のゼロ以外のレーンから値を返します。 (MAXおよびMINと同様に、浮動小数点の負のゼロ-0.0は、デフォルト値である正のゼロとは異なる値として扱われます。 そのため、ゼロ以外のレーン値が存在する場合でも、最初のノズロのレーン削減によって-0.0が返される可能性があります。)
      • ADDおよびMULの場合、正確な結果には任意の演算順序の選択が反映され、時間の経過とともに変化することもあります。 詳細は、「浮動小数点ベクトルに対する演算」の項を参照してください。
      • その他のリダクション演算はすべて、完全に可換的であり、連想的です。 実装では任意の処理順序を選択できますが、常に同じ結果が生成されます。

      パラメータ:
      op - レーン値を結合するために使用される演算
      m - マスク制御レーンの選択
      戻り値:
      選択されたレーン値から累積された還元結果
      例外:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lane

      public abstract float lane(int i)
      レーン索引iのレーン要素を取得
      パラメータ:
      i - レーンのインデックス
      戻り値:
      レーン索引iのレーン要素
      例外:
      IllegalArgumentException - 索引が範囲外の(< 0 || >= length())の場合

    • withLane

      public abstract FloatVector withLane(int i, float e)
      レーン索引iにあるこのベクトルのレーン要素を値eに置き換えます。 これはクロス・レーン演算であり、このベクトルを、eをブロードキャストした結果である入力ベクトルおよびレーン索引iでレーンが1つのみ設定されているマスクとブレンドした結果を返すかのように動作します。
      パラメータ:
      i - 置換されるレーン要素のレーン索引
      e - 配置される値
      戻り値:
      レーン索引iにあるこのベクトルのレーン要素を値eで置き換えた結果。
      例外:
      IllegalArgumentException - 索引が範囲外の(< 0 || >= length())の場合

    • toArray

      public final float[] toArray()
      すべてのレーン値を含むfloat[]型の配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素はレーン順に格納されます。

      このメソッドは、このベクトルを割り当てられた配列(intoArrayを使用して)に格納する場合と同様に動作し、次のように配列を返します: 

      
   float[] a = new float[this.length()];
   this.intoArray(a, 0);
   return a;

      定義:
      クラスVector<Float>のtoArray
      戻り値:
      このベクトルのレーン値を含む配列
      関連項目:

    • toIntArray

      public final int[] toIntArray()
      int型に変換された、すべてのレーン値を含むint[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプが floatまたはdoubleの場合、この演算は失敗する可能性があります。 ベクトル・レーン値がintとして表現できない場合は、例外がスローされます。
      定義:
      クラスVector<Float>のtoIntArray
      戻り値:
      このベクトルのレーン値を含むint[]配列
      関連項目:

    • toLongArray

      public final long[] toLongArray()
      long型に変換された、すべてのレーン値を含むlong[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプが floatまたはdoubleの場合、この演算は失敗する可能性があります。 ベクトル・レーン値がlongとして表現できない場合は、例外がスローされます。
      定義:
      クラスVector<Float>のtoLongArray
      戻り値:
      このベクトルのレーン値を含むlong[]配列
      関連項目:

    • toDoubleArray

      public final double[] toDoubleArray()
      double型に変換された、すべてのレーン値を含むdouble[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 ベクトル要素タイプがlongの場合、この演算によって精度が失われる可能性があります。
      定義:
      クラスVector<Float>のtoDoubleArray
      実装上のノート:
      このメソッドをFloatVector型のベクトルで使用すると、精度は失われません。
      戻り値:
      このベクトルのレーン値を含むdouble[]配列。表現可能なdouble値に丸められる可能性がある
      関連項目:

    • fromByteArray

      public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo)
      オフセットから始まるバイト配列からベクトルをロードします。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

      このメソッドは、次のようにfromByteBuffer()を呼び出した結果を返すかのように動作します: 

      
 var bb = ByteBuffer.wrap(a);
 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

      パラメータ:
      species - 希望するベクトルの種
      a - バイト配列
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー
      戻り値:
      バイト配列からロードされたベクトル
      例外:
      IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N*ESIZE < 0またはoffset+(N+1)*ESIZE > a.lengthの場合

    • fromByteArray

      public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)
      オフセットからマスクを使用してバイト配列からベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のfloat (正のゼロ)が設定されます。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

      このメソッドは、次のようにfromByteBuffer()を呼び出した結果を返すかのように動作します: 

      
 var bb = ByteBuffer.wrap(a);
 return fromByteBuffer(species, bb, offset, bo, m);

      パラメータ:
      species - 希望するベクトルの種
      a - バイト配列
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー
      m - マスク制御レーンの選択
      戻り値:
      バイト配列からロードされたベクトル
      例外:
      IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N*ESIZE < 0またはoffset+(N+1)*ESIZE > a.lengthの場合

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset)
      オフセットから始まるfloat[]型の配列からベクトルをロードします。 Nがベクトル・レーン索引であるベクトル・レーンごとに、索引offset + Nの配列要素がレーン索引Nの結果のベクトルに配置されます。
      パラメータ:
      species - 希望するベクトルの種
      a - 配列
      offset - 配列へのオフセット
      戻り値:
      配列からロードされたベクトル
      例外:
      IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)
      オフセットからマスクを使用して、float[]型の配列からベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のfloat (正のゼロ)が設定されます。 Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのマスク・レーンが設定されている場合、索引offset + Nの配列要素はレーン索引Nの結果のベクトルに配置されます。それ以外の場合、デフォルトの要素値はレーン索引Nの結果のベクトルに配置されます。
      パラメータ:
      species - 希望するベクトルの種
      a - 配列
      offset - 配列へのオフセット
      m - マスク制御レーンの選択
      戻り値:
      配列からロードされたベクトル
      例外:
      IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)
      「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、float[]タイプの配列から要素で構成される新しいベクトルを収集します。 索引マップは、指定されたmapOffsetから始まる、intの別の配列におけるVLENGTH要素の連続したシーケンスです。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、配列要素a[f(N)]からレーンがロードされます。ここで、f(N)は索引マッピング式offset + indexMap[mapOffset + N]]です。

      パラメータ:
      species - 希望するベクトルの種
      a - 配列
      offset - 配列へのオフセット。インデックス・マップ内の相対インデックスが配列境界内の値を生成するよう補正する場合は負の値になることがある
      indexMap - インデックス・マップ
      mapOffset - インデックス・マップへのオフセット
      戻り値:
      配列のインデックス付き要素からロードされたベクトル
      例外:
      IndexOutOfBoundsException - mapOffset+N < 0の場合、またはmapOffset+N >= indexMap.lengthの場合、またはf(N)=offset+indexMap[mapOffset+N]がaへの無効な索引である場合は、ベクトル内のレーンN
      関連項目:

    • fromArray

      public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
      マスクの制御下にあるfloat[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。 索引マップは、指定されたmapOffsetから始まる、intの別の配列におけるVLENGTH要素の連続したシーケンスです。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、レーンがマスクに設定されている場合、そのレーンは配列要素a[f(N)]からロードされます。ここで、f(N)は索引マッピング式offset + indexMap[mapOffset + N]]です。 結果のベクトルのレーンの設定を解除すると、ゼロに設定されます。

      パラメータ:
      species - 希望するベクトルの種
      a - 配列
      offset - 配列へのオフセット。インデックス・マップ内の相対インデックスが配列境界内の値を生成するよう補正する場合は負の値になることがある
      indexMap - インデックス・マップ
      mapOffset - インデックス・マップへのオフセット
      m - マスク制御レーンの選択
      戻り値:
      配列のインデックス付き要素からロードされたベクトル
      例外:
      IndexOutOfBoundsException - mapOffset+N < 0の場合、またはmapOffset+N >= indexMap.lengthの場合、あるいはf(N)=offset+indexMap[mapOffset+N]がaへの無効な索引である場合は、マスクが設定されているベクトル内のレーンN
      関連項目:

    • fromByteBuffer

      public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo)
      オフセットから始まるベクトルをbyte bufferからbyteバッファにロードします。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

      このメソッドは、次のようにfromByteBuffer()を呼び出した結果を返すかのように動作します: 

      
 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

      パラメータ:
      species - 希望するベクトルの種
      bb - byteバッファ
      offset - byteバッファへのオフセット
      bo - 目的のバイト・オーダー
      戻り値:
      byteバッファからロードされたベクトル
      例外:
      IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N*4 < 0またはoffset+N*4 >= bb.limit()の場合

    • fromByteBuffer

      public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)
      オフセットからbyteバッファに開始し、マスクを使用して、byte bufferからベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のfloat (正のゼロ)が設定されます。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

      次の疑似コードは、この動作を示しています: 

      
 FloatBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asFloatBuffer();
 float[] ar = new float[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = eb.get(n);
     }
 }
 FloatVector r = FloatVector.fromArray(species, ar, 0);

      実装上のノート:
      このメソッドはレーン値のバイトを並べ替える必要がないため、指定されたバイト順序が「プラットフォームのネイティブ順序」と同じ場合は、この演算がより効率的になる可能性があります。
      パラメータ:
      species - 希望するベクトルの種
      bb - byteバッファ
      offset - byteバッファへのオフセット
      bo - 目的のバイト・オーダー
      m - マスク制御レーンの選択
      戻り値:
      byteバッファからロードされたベクトル
      例外:
      IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N*4 < 0またはoffset+N*4 >= bb.limit()の場合

    • intoArray

      public final void intoArray(float[] a, int offset)
      このベクトルをオフセットから始まるfloat[]型の配列に格納します。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのレーン要素が配列要素a[offset+N]に格納されます。

      パラメータ:
      a - float[]型の配列
      offset - 配列へのオフセット
      例外:
      IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

    • intoArray

      public final void intoArray(float[] a, int offset, VectorMask<Float> m)
      このベクトルを、オフセットから始めてマスクを使用するfloat[]型の配列に格納します。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのレーン要素が配列要素a[offset+N]に格納されます。 Nのマスク・レーンが設定されていない場合、対応する配列要素a[offset+N]は変更されません。

      配列範囲チェックは、マスクが設定されているレーンに対して実行されます。 マスクが設定されていないレーンは格納されず、aの正当な要素に対応する必要はありません。 つまり、未設定レーンは、ゼロ未満または配列の終わりを超える配列インデックスに対応している可能性があります。

      パラメータ:
      a - float[]型の配列
      offset - 配列へのオフセット
      m - マスク制御レーンのストレージ
      例外:
      IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

    • intoArray

      public final void intoArray(float[] a, int offset, int[] indexMap, int mapOffset)
      「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、このベクトルをfloat[]型の配列に分散します。 索引マップは、指定されたmapOffsetから始まる、intの別の配列におけるVLENGTH要素の連続したシーケンスです。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのレーン要素が配列要素a[f(N)]に格納されます。ここで、f(N)は索引マッピング式offset + indexMap[mapOffset + N]]です。

      パラメータ:
      a - 配列
      offset - インデックス・マップ・オフセットと組み合わせるオフセット
      indexMap - インデックス・マップ
      mapOffset - インデックス・マップへのオフセット
      例外:
      IndexOutOfBoundsException - mapOffset+N < 0の場合、またはmapOffset+N >= indexMap.lengthの場合、またはf(N)=offset+indexMap[mapOffset+N]がaへの無効な索引である場合は、ベクトル内のレーンN
      関連項目:

    • intoArray

      public final void intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)
      このベクトルを、マスクの制御下にあるfloat[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用します。 索引マップは、指定されたmapOffsetから始まる、intの別の配列におけるVLENGTH要素の連続したシーケンスです。

      Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのマスク・レーンが設定されている場合、索引Nのレーン要素が配列要素a[f(N)]に格納されます。ここで、f(N)は索引マッピング式offset + indexMap[mapOffset + N]]です。

      パラメータ:
      a - 配列
      offset - インデックス・マップ・オフセットと組み合わせるオフセット
      indexMap - インデックス・マップ
      mapOffset - インデックス・マップへのオフセット
      m - マスク
      例外:
      IndexOutOfBoundsException - mapOffset+N < 0の場合、またはmapOffset+N >= indexMap.lengthの場合、あるいはf(N)=offset+indexMap[mapOffset+N]がaへの無効な索引である場合は、マスクが設定されているベクトル内のレーンN
      関連項目:

    • intoByteArray

      public final void intoByteArray(byte[] a, int offset, ByteOrder bo)
      明示的なバイト順序を使用して、オフセットから始まるバイト配列にこのベクトルを格納します。

      バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。

      このメソッドは、次のようにintoByteBuffer()をコールするかのように動作します: 

      
 var bb = ByteBuffer.wrap(a);
 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

      定義:
      クラスVector<Float>のintoByteArray
      パラメータ:
      a - バイト配列
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー

    • intoByteArray

      public final void intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)
      明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。

      バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。

      このメソッドは、次のようにintoByteBuffer()をコールするかのように動作します: 

      
 var bb = ByteBuffer.wrap(a);
 intoByteBuffer(bb, offset, bo, m);

      定義:
      クラスVector<Float>のintoByteArray
      パラメータ:
      a - バイト配列
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー
      m - マスク制御レーンの選択

    • intoByteBuffer

      public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)
      明示的なバイト順序を使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。

      バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。

      このメソッドは、次のようにintoByteBuffer()をコールするかのように動作します: 

      
 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

      定義:
      クラスVector<Float>のintoByteBuffer
      パラメータ:
      bb - byteバッファ
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー

    • intoByteBuffer

      public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)
      明示的なバイト順序とマスクを使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。

      バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。

      次の擬似コードは、プリミティブ要素の型がbyteではなく、EBufferがプリミティブ・バッファ・タイプ、ETYPEがプリミティブ要素の型、EVectorがこのベクトルのプリミティブ・ベクトル・タイプである場合の動作を示しています: 

      
 EBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asEBuffer();
 ETYPE[] a = this.toArray();
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         eb.put(n, a[n]);
     }
 }
      プリミティブ要素の型がbyteの場合、プリミティブ・バイト・バッファは次のように取得されます。バッファに対する演算は、前の擬似コードと同じままです: 
      
 ByteBuffer eb = bb.duplicate()
     .position(offset);

      定義:
      クラスVector<Float>のintoByteBuffer
      パラメータ:
      bb - byteバッファ
      offset - 配列へのオフセット
      bo - 目的のバイト・オーダー
      m - マスク制御レーンの選択

    • reinterpretAsBytes

      public final ByteVector reinterpretAsBytes()
      このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyteでは、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。 これは、式reinterpretShape(species().withLanes(byte.class))の簡易メソッドです。 これは、Vector.reinterpretAsInts()など、同じベクトル内の大きいレーンにバイトを統合する様々なメソッドとは逆であると考えられます。
      定義:
      クラスVector<Float>のreinterpretAsBytes
      戻り値:
      同じシェイプおよび情報コンテンツを持つByteVector
      関連項目:

    • viewAsIntegralLanes

      public final IntVector viewAsIntegralLanes()
      このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPEまたはVLENGTHを変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPEがすでに整数型である場合、同じベクトルが変更されずに返されます。 このメソッドは、この式の値を戻します: convert(conv,0)。ここで、convはVectorOperators.Conversion.ofReinterpret(E.class,F.class)で、FはEと同じサイズの非浮動小数点型です。
      定義:
      クラスVector<Float>のviewAsIntegralLanes
      戻り値:
      非浮動小数点として再解釈された、元のベクトル
      関連項目:

    • viewAsFloatingLanes

      public final FloatVector viewAsFloatingLanes()
      このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPEまたはVLENGTHを変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPEがすでに浮動小数点型である場合、同じベクトルが変更されずに返されます。 ベクトル要素のサイズが浮動小数点型のサイズと一致しない場合は、IllegalArgumentExceptionがスローされます。 このメソッドは、この式の値を戻します: convert(conv,0)。convはVectorOperators.Conversion.ofReinterpret(E.class,F.class)で、FはEと同じサイズの浮動小数点型です(存在する場合)。
      定義:
      クラスVector<Float>のviewAsFloatingLanes
      戻り値:
      浮動小数点として再解釈された、元のベクトル
      関連項目:

    • toString

      public final String toString()
      このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"形式のこのベクトルの文字列表現を返します。 この文字列は、this.toArray()から返されるfloat配列に応じて、Arrays.toString()へのコールによって生成されるかのように生成されます。
      定義:
      クラスVector<Float>のtoString
      戻り値:
      このベクトルのレーン値を報告する"[0,1,2...]"形式の文字列

    • equals

      public final boolean equals(Object obj)
      このベクトルが他のオブジェクトと同一かどうかを示します。 2つのベクトルは、同じ種と同じレーン値を同じ順序で持つ場合にのみ同一です。

      レーン値の比較は、両方のベクトルのtoArray()によって返される配列に応じて、Arrays.equals()をコールした場合と同様に生成されます。

      定義:
      クラスVector<Float>のequals
      パラメータ:
      obj - 比較対象の参照オブジェクト。
      戻り値:
      このベクトルがほかのオブジェクトと同一かどうか
      関連項目:

    • hashCode

      public final int hashCode()
      レーン値とベクトル種に基づいて、ベクトルのハッシュ・コード値を返します。
      定義:
      クラスVector<Float>のhashCode
      戻り値:
      このベクトルのハッシュ・コード値
      関連項目:

    • species

      public final VectorSpecies<Float> species()
      クラス: Vectorからコピーされた説明
      このベクトルの種を返します。
      定義:
      クラスVector<E>のspecies
      戻り値:
      このベクトルの種

    • check

      public final <F> Vector<F> check(VectorSpecies<F> species)
      クラス: Vectorからコピーされた説明
      このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。 効果は次の疑似コードのようになります : species == species() ? this : throw new ClassCastException()。
      定義:
      クラスVector<E>のcheck
      型パラメータ:
      F - 必要な種のボックス化された要素型
      パラメータ:
      species - 必要な種
      戻り値:
      同じベクトル
      関連項目:

    • check

      public final <F> Vector<F> check(Class<F> elementType)
      このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。 効果は次の疑似コードのようになります : elementType == species().elementType() ? this : throw new ClassCastException()。
      定義:
      クラスVector<E>のcheck
      型パラメータ:
      F - 必要なレーン型のボックス化された要素型
      パラメータ:
      elementType - 必要なレーン・タイプ
      戻り値:
      同じベクトル
      関連項目:

    • maskAll

      public final VectorMask<Float> maskAll(boolean bit)
      このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。

      このメソッドは、この式の値を戻します: species().maskAll(bit)。

      定義:
      クラスVector<E>のmaskAll
      パラメータ:
      bit - 複製される指定されたマスク・ビット
      戻り値:
      指定されたビットに従って各レーンが設定または設定解除されるマスク
      関連項目:

    • reinterpretAsShorts

      public ShortVector reinterpretAsShorts()
      このベクトルを、同じシェイプおよび内容でレーン型のshortのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(short.class))の簡易メソッドです。 Vector.reinterpretAsBytes()とは逆の場合があります。
      定義:
      クラスVector<E>のreinterpretAsShorts
      戻り値:
      同じシェイプおよび情報コンテンツを持つShortVector

    • reinterpretAsInts

      public IntVector reinterpretAsInts()
      このベクトルを、同じシェイプおよび内容でレーン型のintのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(int.class))の簡易メソッドです。 Vector.reinterpretAsBytes()とは逆の場合があります。
      定義:
      クラスVector<E>のreinterpretAsInts
      戻り値:
      同じシェイプおよび情報コンテンツを持つIntVector

    • reinterpretAsLongs

      public LongVector reinterpretAsLongs()
      このベクトルを、同じシェイプおよび内容でレーン型のlongのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(long.class))の簡易メソッドです。 Vector.reinterpretAsBytes()とは逆の場合があります。
      定義:
      クラスVector<E>のreinterpretAsLongs
      戻り値:
      同じシェイプおよび情報コンテンツを持つLongVector

    • reinterpretAsFloats

      public FloatVector reinterpretAsFloats()
      このベクトルを、同じシェイプおよび内容でレーン型のfloatのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(float.class))の簡易メソッドです。 Vector.reinterpretAsBytes()とは逆の場合があります。
      定義:
      クラスVector<E>のreinterpretAsFloats
      戻り値:
      同じシェイプおよび情報コンテンツを持つFloatVector

    • reinterpretAsDoubles

      public DoubleVector reinterpretAsDoubles()
      このベクトルを、同じシェイプおよび内容でレーン型のdoubleのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(double.class))の簡易メソッドです。 Vector.reinterpretAsBytes()とは逆の場合があります。
      定義:
      クラスVector<E>のreinterpretAsDoubles
      戻り値:
      同じシェイプおよび情報コンテンツを持つDoubleVector

    • convert

      public final <F> Vector<F> convert(VectorOperators.Conversion<Float,F> conv, int part)
      指定された「変換」に従って、このベクトルを同じシェイプのベクトルおよび新しい要素タイプに変換し、レーン値を現在のETYPEから新しいレーン型の(ここではFTYPEと呼びます)に変換します。 これは、入力ベクトルから結果内の対応するFTYPE値にETYPE値をコピーするレーンワイズ・シェイプ不変演算です。 選択した変換に応じて、この演算によって「拡大または縮小」の論理結果が生成される場合があります。その場合、ゼロ以外のpart番号によって、論理結果の選択および物理出力ベクトルへのリングをさらに制御できます。

      個々の変換は、VectorOperatorsクラスの変換定数によって記述されます。 各変換演算子には、指定された「ドメイン・タイプ」および「範囲タイプ」があります。 ドメイン・タイプは入力ベクトルのレーン・タイプと完全に一致する必要があり、範囲タイプは出力ベクトルのレーン・タイプを決定します。

      変換演算子は、そのドメイン型のビット・サイズが(respectively)の範囲型のビット・サイズと等しいか、小さいか、大きいかによって、(respectively)のインプレース、拡張または縮小として分類されます。

      変換演算は、変換によって表現ビットが変更されていないかどうかに応じて再入力または値変換として分類することも、入力値の論理値を(一部またはすべて)に保持するために表現ビットを変更することもできます。

      再解釈変換縮小の場合は、入力の上位ビットが切り捨てられます。 対応する入力ビットがない場合は、拡張すると出力の上位ビットにゼロ・ビットが埋め込まれます。

      S2I (short値をintに)などの拡張変換では、スカラー値が使用され、より大きい形式の(情報の冗長性を常に確保)で表されます。 D2F (double値をfloatに)などの縮小変換では、スカラー値が使用され、より小さい形式の(情報が失われた場合は常に)で表されます。 一部のインプレース変換には、L2D (long値をdoubleに)やF2I (float値をintに)などの情報損失が含まれる場合もあります。 インプレース変換の再解釈は、ビット単位の値が出力タイプである程度正当でない場合を除き、失われることはありません。 NaNのビット・パターンを変換すると、NaNの意味からビットが破棄されることがあります。

      この分類は、特に記載のないかぎり、「レーン・サイズ」の変更方法に関係なく変換演算「ベクトル・シェイプを変更しない」で重要です。 したがって、「拡張」変換では、そのすべての結果を出力ベクトルに格納できません。これは、入力と同じ全体的なビット・サイズにするために、出力ベクトルのレーンのサイズが小さくなるためです。 同様に、縮小変換では、比較的小さい結果を出力ベクトルのレーンのサブセットに格納し、未使用レーンをゼロにデフォルト設定する必要があります。

      たとえば、byteからlong (M=8)への変換では、残りの12.5%を出力ベクトルのroomy longレーンに変換するために、入力値の87.5%が破棄されます。 逆変換では、大きな結果がすべて変換されますが、出力ベクトル内のレーンの87.5 %が無駄になります。 In-place変換(M=1)は、レーンを無駄にせずに、すべての結果を単一の出力ベクトルで配信します。

      これらの「拡張と縮小」の詳細を管理するには、ゼロ以外のpartパラメータを使用して、拡張から部分的な結果を選択するか、次のように対応するロケーションに縮小の結果をステアします:

      • Mによる拡張: partは[0..M-1]の範囲内にある必要があり、part*VLENGTH/Mの原点レーンから始まるVLENGTH/M入力レーンのブロックを選択します。

        VLENGTH/M出力レーンは、変換の論理結果全体の一部を表し、物理出力ベクトル全体を埋めます。

      • Mで縮小: partは[-M+1..0]の範囲内にある必要があり、原点レーン -part*VLENGTHにある出力にすべてのVLENGTH入力レーンをステアします。 合計VLENGTH*M出力レーンがあり、変換された入力値を保持していない出力レーンにはゼロが入力されます。

        このような出力ベクトルのグループは、論理結果部分が無関係なブロックに盗まれた状態で、「ビット単位または」または(浮動小数点)のFIRST_NONZERO演算子を使用して再アセンブルできます。

      • in-place (M=1): partはゼロである必要があります。 どちらのベクトルも同じVLENGTHを持ちます。 結果は常にゼロの「原点レーン」に配置されます。

      このメソッドは、より一般的ですが、使用頻度の低いshape-changingメソッドconvertShape()の制限付きバージョンです。 このメソッドの結果は、出力種がrsp=this.species().withLanes(FTYPE.class)である式this.convertShape(conv, rsp, this.broadcast(part))と同じです。

      定義:
      クラスVector<E>のconvert
      型パラメータ:
      F - 種のboxed要素の型
      パラメータ:
      conv - レーンワイズ適用に必要なスカラー変換
      part - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルからシェイプおよび要素型によって変換されたベクトル
      関連項目:

    • castShape

      public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)
      ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。 このメソッドは、この式の値を戻します: convertShape(conv,rsp,part)。convはVectorOperators.Conversion.ofCast(E.class,F.class)です。

      新旧の種のシェイプが異なる場合、これはshape-changing演算であり、特別な実装コストがかかる可能性があります。

      定義:
      クラスVector<E>のcastShape
      型パラメータ:
      F - 出力種のboxed要素型
      パラメータ:
      toSpecies - 目的の出力種
      part - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルから要素型によって変換されたベクトル
      関連項目:

    • convertShape

      public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Float,F> conv, VectorSpecies<F> rsp, int part)
      指定された「変換」に従って、このベクトルを指定された種、シェイプ、および要素型のベクトルに変換し、レーン値を現在のETYPEから新しいレーン型(ここではFTYPEと呼びます)に変換します。 これは、入力ベクトルから結果内の対応するFTYPE値にETYPE値をコピーするレーンワイズ演算です。

      新旧の種のシェイプが同じ場合、その動作は単純なシェイプ不変メソッドconvert()とまったく同じです。 このような場合は、コードの理由を簡単にするために、より単純なメソッドconvert()を使用する必要があります。 それ以外の場合、これはshape-changing演算であり、特別な実装コストがかかる可能性があります。

      シェイプの変更とレーンのサイズの変更を組み合せた効果として、入出力種のレーン数が異なる場合があり、その場合は「拡大または縮小」が発生します。 この場合、ゼロ以外のpartパラメータは、拡張された論理結果から部分的な結果を選択するか、縮小された論理結果の結果を必要な出力種の物理出力ベクトルにステアします。

      次の擬似コードは、インプレース、拡張および縮小変換に対するこのメソッドの動作を示しています。 (この擬似コードはシェイプ不変メソッドにも適用されますが、出力種にはシェイプ制限があります。) 変換演算子とシェイプの特定の組合せに関連するのは、3つのコード・パスのうちの1つのみです。 

      
 FTYPE scalar_conversion_op(ETYPE s);
 EVector a = ...;
 VectorSpecies<F> rsp = ...;
 int part = ...;
 VectorSpecies<E> dsp = a.species();
 int domlen = dsp.length();
 int ranlen = rsp.length();
 FTYPE[] logical = new FTYPE[domlen];
 for (int i = 0; i < domlen; i++) {
   logical[i] = scalar_conversion_op(a.lane(i));
 }
 FTYPE[] physical;
 if (domlen == ranlen) { // in-place
     assert part == 0; //else AIOOBE
     physical = logical;
 } else if (domlen > ranlen) { // expanding
     int M = domlen / ranlen;
     assert 0 <= part && part < M; //else AIOOBE
     int origin = part * ranlen;
     physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // contracting
     int M = ranlen / domlen;
     assert 0 >= part && part > -M; //else AIOOBE
     int origin = -part * domlen;
     System.arraycopy(logical, 0, physical, origin, domlen);
 }
 return FVector.fromArray(ran, physical, 0);

      定義:
      クラスVector<E>のconvertShape
      型パラメータ:
      F - 出力種のboxed要素型
      パラメータ:
      conv - レーンワイズ適用に必要なスカラー変換
      rsp - 目的の出力種
      part - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルから要素型によって変換されたベクトル
      関連項目: