byte
値のシーケンスを表す特殊なVector
。-
フィールドのサマリー
修飾子と型フィールド説明static VectorSpecies<Byte>
static VectorSpecies<Byte>
static VectorSpecies<Byte>
static VectorSpecies<Byte>
static VectorSpecies<Byte>
static VectorSpecies<Byte>
ByteVector
の優先種。 -
メソッドのサマリー
修飾子と型メソッド説明abs()
このベクトルの絶対値を返します。add(byte e)
このベクトルを入力スカラーのブロードキャストに追加します。add(byte e, VectorMask<Byte> m)
このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。このベクトルを2番目の入力ベクトルに追加します。add(Vector<Byte> v, VectorMask<Byte> m)
マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。abstract ByteVector
addIndex(int scale)
指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。and(byte e)
このベクトルとスカラーのビット単位の論理積(&
)を計算します。このベクトルと次の入力ベクトルのビット単位の論理積(&
)を計算します。bitwiseBlend(byte bits, byte mask)
マスク・ビットを提供する別のスカラーの制御下にあるベクトルとスカラーのビットをブレンドします。bitwiseBlend(byte bits, Vector<Byte> mask)
マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。bitwiseBlend(Vector<Byte> bits, byte mask)
マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)
マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。blend(byte e, VectorMask<Byte> m)
このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。blend(long e, VectorMask<Byte> m)
このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。abstract ByteVector
blend(Vector<Byte> v, VectorMask<Byte> m)
このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。abstract ByteVector
broadcast(byte e)
すべてのレーン要素がプリミティブ値e
に設定されている、この種と同じ種のベクトルを返します。abstract ByteVector
broadcast(long e)
すべてのレーン要素がプリミティブ値e
に設定されている、この種と同じ種のベクトルを返します。static ByteVector
broadcast(VectorSpecies<Byte> species, byte e)
すべてのレーン要素がプリミティブ値e
に設定されている、指定された種のベクトルを返します。static ByteVector
broadcast(VectorSpecies<Byte> species, long e)
すべてのレーン要素がプリミティブ値e
に設定されている、指定された種のベクトルを返します。<F> Vector<F>
castShape(VectorSpecies<F> toSpecies, int part)
ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。<F> Vector<F>
このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。<F> Vector<F>
check(VectorSpecies<F> species)
このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。abstract VectorMask<Byte>
compare(VectorOperators.Comparison op, byte e)
指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)
指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。abstract VectorMask<Byte>
compare(VectorOperators.Comparison op, long e)
指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)
指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。abstract VectorMask<Byte>
compare(VectorOperators.Comparison op, Vector<Byte> v)
指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。compare(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)
このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。<F> Vector<F>
convert(VectorOperators.Conversion<Byte,F> conv, int part)
指定された「変換」に従って、このベクトルを同じシェイプのベクトルおよび新しい要素タイプに変換し、レーン値を現在のETYPE
から新しいレーン型の(ここではFTYPE
と呼びます)に変換します。abstract <F> Vector<F>
convertShape(VectorOperators.Conversion<Byte,F> conv, VectorSpecies<F> rsp, int part)
指定された「変換」に従って、このベクトルを指定された種、シェイプ、および要素型のベクトルに変換し、レーン値を現在のETYPE
から新しいレーン型(ここではFTYPE
と呼びます)に変換します。div(byte e)
このベクトルを入力スカラーのブロードキャストで除算します。div(byte e, VectorMask<Byte> m)
このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。このベクトルを2番目の入力ベクトルで除算します。div(Vector<Byte> v, VectorMask<Byte> m)
このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。eq(byte e)
このベクトルが入力スカラーと等しいかどうかを判定します。このベクトルが別の入力ベクトルと等しいかどうかを判定します。boolean
このベクトルが他のオブジェクトと同一かどうかを示します。static ByteVector
fromArray(VectorSpecies<Byte> species, byte[] a, int offset)
オフセットから始まるbyte[]
型の配列からベクトルをロードします。static ByteVector
fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)
「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用して、byte[]
タイプの配列から要素で構成される新しいベクトルを収集します。static ByteVector
fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
マスクの制御下にあるbyte[]
型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用します。static ByteVector
fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)
オフセットからマスクを使用して、byte[]
型の配列からベクトルをロードします。static ByteVector
fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo)
オフセットから始まるバイト配列からベクトルをロードします。static ByteVector
fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)
オフセットからマスクを使用してバイト配列からベクトルをロードします。static ByteVector
fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo)
オフセットから始まるベクトルをbyte bufferからbyteバッファにロードします。static ByteVector
fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)
オフセットからbyteバッファに開始し、マスクを使用して、byte bufferからベクトルをロードします。int
hashCode()
ベクトルのハッシュ・コード値を返します。void
intoArray(byte[] a, int offset)
このベクトルをオフセットから始まるbyte[]
型の配列に格納します。void
intoArray(byte[] a, int offset, int[] indexMap, int mapOffset)
「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用して、このベクトルをbyte[]
型の配列に分散します。void
intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
このベクトルを、マスクの制御下にあるbyte[]
型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用します。void
intoArray(byte[] a, int offset, VectorMask<Byte> m)
オフセットからマスクを使用して、このベクトルをbyte
の配列に格納します。void
intoByteArray(byte[] a, int offset, ByteOrder bo)
明示的なバイト順序を使用して、オフセットから始まるバイト配列にこのベクトルを格納します。void
intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)
明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。void
intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)
明示的なバイト順序を使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。void
intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)
明示的なバイト順序とマスクを使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。abstract byte
lane(int i)
レーン索引i
のレーン要素を取得lanewise(VectorOperators.Binary op, byte e)
このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)
このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。lanewise(VectorOperators.Binary op, long e)
このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)
このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。abstract ByteVector
lanewise(VectorOperators.Binary op, Vector<Byte> v)
このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)
このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。lanewise(VectorOperators.Ternary op, byte e1, byte e2)
このベクトルのレーンの値を2つのブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)
このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)
このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)
このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)
このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)
このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。abstract ByteVector
このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)
このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。abstract ByteVector
このベクトルのレーン値を操作します。lanewise(VectorOperators.Unary op, VectorMask<Byte> m)
マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。lt(byte e)
このベクトルが入力スカラーより小さいかどうかを判定します。このベクトルが別の入力ベクトルより小さいかどうかを判定します。maskAll(boolean bit)
このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。max(byte e)
このベクトルの大きい方と入力スカラーのブロードキャストを計算します。このベクトルと2番目の入力ベクトルの大きい方を計算します。min(byte e)
このベクトルの小さい方と入力スカラーのブロードキャストを計算します。このベクトルと2番目の入力ベクトルの小さい方を計算します。mul(byte e)
このベクトルに入力スカラーのブロードキャストを掛けます。mul(byte e, VectorMask<Byte> m)
このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。このベクトルに2番目の入力ベクトルを掛けます。mul(Vector<Byte> v, VectorMask<Byte> m)
マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。neg()
このベクトルを否定します。not()
このベクトルのビット単位の論理補数(~
)を計算します。or(byte e)
このベクトルとスカラーのビット単位の論理和(|
)を計算します。このベクトルと別の入力ベクトルのビット単位の論理和(|
)を計算します。abstract ByteVector
rearrange(VectorShuffle<Byte> m)
特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。abstract ByteVector
rearrange(VectorShuffle<Byte> s, Vector<Byte> v)
特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。abstract ByteVector
rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)
特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。abstract byte
このベクトルのすべてのレーンから累積された値を返します。abstract byte
マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyte
では、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。このベクトルを、同じシェイプおよび内容でレーン型のdouble
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。このベクトルを、同じシェイプおよび内容でレーン型のfloat
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。このベクトルを、同じシェイプおよび内容でレーン型のint
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。このベクトルを、同じシェイプおよび内容でレーン型のlong
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。このベクトルを、同じシェイプおよび内容でレーン型のshort
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract ByteVector
selectFrom(Vector<Byte> v)
このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。abstract ByteVector
selectFrom(Vector<Byte> s, VectorMask<Byte> m)
このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。abstract ByteVector
slice(int origin)
現在のベクトル内の指定されたorigin
レーンから始まる隣接レーンのセグメントをスライスします。abstract ByteVector
現在のベクトル内の指定されたorigin
レーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。slice(int origin, Vector<Byte> w, VectorMask<Byte> m)
マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたorigin
レーンから開始し、(必要に応じて)を直後のベクトルに継続します。species()
このベクトルの種を返します。sub(byte e)
このベクトルから入力スカラーを減算します。sub(byte e, VectorMask<Byte> m)
マスクの制御下にあるこのベクトルから入力スカラーを減算します。このベクトルから2番目の入力ベクトルを減算します。sub(Vector<Byte> v, VectorMask<Byte> m)
マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。abstract VectorMask<Byte>
test(VectorOperators.Test op)
指定された演算に従って、このベクトルのレーンをテストします。test(VectorOperators.Test op, VectorMask<Byte> m)
指定された演算に従って、このベクトルの選択されたレーンをテストします。byte[]
toArray()
すべてのレーン値を含むbyte[]
型の配列を返します。double[]
double
型に変換された、すべてのレーン値を含むdouble[]
配列を返します。int[]
int
型に変換された、すべてのレーン値を含むint[]
配列を返します。long[]
long
型に変換された、すべてのレーン値を含むlong[]
配列を返します。toString()
このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"
形式のこのベクトルの文字列表現を返します。abstract ByteVector
unslice(int origin)
slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。abstract ByteVector
slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。abstract ByteVector
unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)
slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。Vector<?>
このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。abstract ByteVector
withLane(int i, byte e)
レーン索引i
にあるこのベクトルのレーン要素を値e
に置き換えます。static ByteVector
zero(VectorSpecies<Byte> species)
すべてのレーン要素がデフォルトのプリミティブ値であるゼロに設定されている、指定された種のベクトルを返します。クラスjdk.incubator.vector.Vectorで宣言されたメソッド
bitSize, byteSize, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle
クラスjdk.internal.vm.vector.VectorSupport.VectorPayloadで宣言されたメソッド
getPayload
-
フィールド詳細
-
SPECIES_64
public static final VectorSpecies<Byte> SPECIES_64 -
SPECIES_128
public static final VectorSpecies<Byte> SPECIES_128 -
SPECIES_256
public static final VectorSpecies<Byte> SPECIES_256 -
SPECIES_512
public static final VectorSpecies<Byte> SPECIES_512 -
SPECIES_MAX
public static final VectorSpecies<Byte> SPECIES_MAX -
SPECIES_PREFERRED
public static final VectorSpecies<Byte> SPECIES_PREFERREDByteVector
の優先種。 優先種はプラットフォームの最大ビット・サイズの一種です。
-
-
メソッドの詳細
-
zero
public static ByteVector zero(VectorSpecies<Byte> species)すべてのレーン要素がデフォルトのプリミティブ値であるゼロに設定されている、指定された種のベクトルを返します。- パラメータ:
species
- 目的のゼロ・ベクトルの種- 戻り値:
- ゼロ・ベクトル
-
broadcast
public abstract ByteVector broadcast(byte e)すべてのレーン要素がプリミティブ値e
に設定されている、この種と同じ種のベクトルを返します。 現在のベクトルの内容は破棄されます。この演算に関連するのは種だけです。このメソッドは、この式の値を戻します:
ByteVector.broadcast(this.species(), e)
。- APIのノート:
- スーパータイプ
Vector
のbroadcast()
という名前の同様のメソッドとは異なり、このメソッドはその引数を検証する必要はなく、IllegalArgumentException
をスローできません。 したがって、このメソッドはスーパータイプ・メソッドよりも推奨されます。 - パラメータ:
e
- ブロードキャストする値- 戻り値:
- すべてのレーン要素がプリミティブ値
e
に設定されているベクトル - 関連項目:
broadcast(VectorSpecies,long)
,Vector.broadcast(long)
,VectorSpecies.broadcast(long)
-
broadcast
public static ByteVector broadcast(VectorSpecies<Byte> species, byte e)すべてのレーン要素がプリミティブ値e
に設定されている、指定された種のベクトルを返します。- パラメータ:
species
- 希望するベクトルの種e
- ブロードキャストする値- 戻り値:
- すべてのレーン要素がプリミティブ値
e
に設定されているベクトル - 関連項目:
broadcast(long)
,Vector.broadcast(long)
,VectorSpecies.broadcast(long)
-
broadcast
public abstract ByteVector 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<Byte>
のbroadcast
- APIのノート:
ByteVector
などのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます:v.broadcast((byte)e)
。 この2つの式は、数値的に同一の結果を生成します。- パラメータ:
e
- ブロードキャストする値- 戻り値:
- すべてのレーン要素がプリミティブ値
e
に設定されているベクトル - 関連項目:
VectorSpecies.broadcast(long)
,IntVector.broadcast(int)
,FloatVector.broadcast(float)
-
broadcast
public static ByteVector broadcast(VectorSpecies<Byte> species, long e)すべてのレーン要素がプリミティブ値e
に設定されている、指定された種のベクトルを返します。long
値は、e==(long)(ETYPE)e
のようにベクトル種のETYPE
で正確に表現できる必要があります。- パラメータ:
species
- 希望するベクトルの種e
- ブロードキャストする値- 戻り値:
- すべてのレーン要素がプリミティブ値
e
に設定されているベクトル - 例外:
IllegalArgumentException
- 指定されたlong
値をベクトルETYPE
で表現できない場合- 関連項目:
broadcast(VectorSpecies,byte)
,VectorSpecies.checkValue(long)
-
lanewise
public abstract ByteVector lanewise(VectorOperators.Unary op)このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値の処理に使用される演算- 戻り値:
- 入力ベクトルにレーンワイズ演算を適用した結果
- 関連項目:
VectorOperators.NEG
,VectorOperators.NOT
,VectorOperators.SIN
,Vector.lanewise(VectorOperators.Unary,VectorMask)
,Vector.lanewise(VectorOperators.Binary,Vector)
,Vector.lanewise(VectorOperators.Ternary,Vector,Vector)
-
lanewise
public final ByteVector lanewise(VectorOperators.Unary op, VectorMask<Byte> m)マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値の処理に使用される演算m
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルにレーンワイズ演算を適用した結果
- 関連項目:
Vector.lanewise(VectorOperators.Unary)
-
lanewise
public abstract ByteVector lanewise(VectorOperators.Binary op, Vector<Byte> v)このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値を結合するために使用される演算v
- 入力ベクトル- 戻り値:
- 2つの入力ベクトルにレーンワイズ演算を適用した結果
- 関連項目:
lanewise(VectorOperators.Binary,byte)
,lanewise(VectorOperators.Binary,byte,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値を結合するために使用される演算v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 2つの入力ベクトルにレーンワイズ演算を適用した結果
- 関連項目:
lanewise(VectorOperators.Binary,byte,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Binary op, byte e)このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e))
。- パラメータ:
op
- レーン値の処理に使用される演算e
- 入力スカラー- 戻り値:
- 2つの入力ベクトルにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ二項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e), m)
。- パラメータ:
op
- レーン値の処理に使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルとスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Binary,Vector,VectorMask)
,lanewise(VectorOperators.Binary,byte)
-
lanewise
public final ByteVector lanewise(VectorOperators.Binary op, long e)このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e))
。- 定義:
- クラス
Vector<Byte>
のlanewise
- APIのノート:
ByteVector
などのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます:v.lanewise(op,(byte)e)
。 この2つの式は、数値的に同一の結果を生成します。- パラメータ:
op
- レーン値を結合するために使用される演算e
- 入力スカラー- 戻り値:
- 入力ベクトルとスカラーにレーンワイズ演算を適用した結果
- 関連項目:
Vector.broadcast(long)
,Vector.lanewise(VectorOperators.Binary,long,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 2番目のオペランドはブロードキャスト整数値です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e), m)
。- 定義:
- クラス
Vector<Byte>
のlanewise
- APIのノート:
ByteVector
などのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます:v.lanewise(op,(byte)e,m)
。 この2つの式は、数値的に同一の結果を生成します。- パラメータ:
op
- レーン値を結合するために使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルとスカラーにレーンワイズ演算を適用した結果
- 関連項目:
Vector.broadcast(long)
,Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)
-
lanewise
public abstract ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。 これは、選択した演算を各レーンに適用するレーンワイズの三項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値を結合するために使用される演算v1
- 2番目の入力ベクトルv2
- 3番目の入力ベクトル- 戻り値:
- 3つの入力ベクトルに演算レーンワイズを適用した結果
- 関連項目:
lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
,lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
,lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)
,lanewise(VectorOperators.Ternary,byte,byte)
,lanewise(VectorOperators.Ternary,Vector,byte)
,lanewise(VectorOperators.Ternary,byte,Vector)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。- 定義:
- クラス
Vector<Byte>
のlanewise
- パラメータ:
op
- レーン値を結合するために使用される演算v1
- 2番目の入力ベクトルv2
- 3番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 3つの入力ベクトルに演算レーンワイズを適用した結果
- 関連項目:
lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
,lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
,lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, byte e2)このベクトルのレーンの値を2つのブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e1), this.broadcast(e2))
。- パラメータ:
op
- レーン値を結合するために使用される演算e1
- 最初の入力スカラーe2
- 2番目の入力スカラー- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector)
,lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)このベクトルのレーンの値と2つのブロードキャスト・スカラーの値を組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)
。- パラメータ:
op
- レーン値を結合するために使用される演算e1
- 最初の入力スカラーe2
- 2番目の入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
,lanewise(VectorOperators.Ternary,byte,byte)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, v1, this.broadcast(e2))
。- パラメータ:
op
- レーン値を結合するために使用される演算v1
- その他の入力ベクトルe2
- 入力スカラー- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,byte,byte)
,lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, v1, this.broadcast(e2), m)
。- パラメータ:
op
- レーン値を結合するために使用される演算v1
- その他の入力ベクトルe2
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector)
,lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
,lanewise(VectorOperators.Ternary,Vector,byte)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e1), v2)
。- パラメータ:
op
- レーン値を結合するために使用される演算e1
- 入力スカラーv2
- その他の入力ベクトル- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector)
,lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)
-
lanewise
public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e1), v2, m)
。- パラメータ:
op
- レーン値を結合するために使用される演算e1
- 入力スカラーv2
- その他の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
,lanewise(VectorOperators.Ternary,byte,Vector)
-
add
public final ByteVector add(Vector<Byte> v) -
add
public final ByteVector add(byte e)このベクトルを入力スカラーのブロードキャストに追加します。 これは、プリミティブ加算演算(+
)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
ADD
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルの各レーンをスカラーに加算した結果
- 関連項目:
add(Vector)
,broadcast(byte)
,add(byte,VectorMask)
,VectorOperators.ADD
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
add
public final ByteVector add(Vector<Byte> v, VectorMask<Byte> m)マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。 これは、対応するレーン値の各ペアにプリミティブ加算演算(+
)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
ADD
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- 定義:
- クラス
Vector<Byte>
のadd
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 指定されたベクトルにこのベクトルを追加した結果
- 関連項目:
add(byte,VectorMask)
-
add
public final ByteVector add(byte e, VectorMask<Byte> m)このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。 これは、各レーンにプリミティブ加算演算(+
)を適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise
(
ADD
, s, m)
とも同じです。- パラメータ:
e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- このベクトルの各レーンをスカラーに加算した結果
- 関連項目:
add(Vector,VectorMask)
,broadcast(byte)
,add(byte)
,VectorOperators.ADD
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
sub
public final ByteVector sub(Vector<Byte> v) -
sub
public final ByteVector sub(byte e)このベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-
)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise
(
SUB
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルの各レーンからスカラーを減算した結果
- 関連項目:
sub(Vector)
,broadcast(byte)
,sub(byte,VectorMask)
,VectorOperators.SUB
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
sub
public final ByteVector sub(Vector<Byte> v, VectorMask<Byte> m)マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。 これは、対応するレーン値の各ペアにプリミティブ減算演算(-
)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
SUB
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- 定義:
- クラス
Vector<Byte>
のsub
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルから2番目の入力ベクトルを減算した結果
- 関連項目:
sub(byte,VectorMask)
-
sub
public final ByteVector sub(byte e, VectorMask<Byte> m)マスクの制御下にあるこのベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-
)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise
(
SUB
, s, m)
とも同じです。- パラメータ:
e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- このベクトルの各レーンからスカラーを減算した結果
- 関連項目:
sub(Vector,VectorMask)
,broadcast(byte)
,sub(byte)
,VectorOperators.SUB
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
mul
public final ByteVector mul(Vector<Byte> v) -
mul
public final ByteVector mul(byte e)このベクトルに入力スカラーのブロードキャストを掛けます。 これは、プリミティブ乗算演算(*
)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MUL
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルに指定されたスカラーを掛けた結果
- 関連項目:
mul(Vector)
,broadcast(byte)
,mul(byte,VectorMask)
,VectorOperators.MUL
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
mul
public final ByteVector mul(Vector<Byte> v, VectorMask<Byte> m)マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。 これは、プリミティブ乗算演算(*
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
MUL
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- 定義:
- クラス
Vector<Byte>
のmul
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルに指定されたベクトルを掛けた結果
- 関連項目:
mul(byte,VectorMask)
-
mul
public final ByteVector mul(byte e, VectorMask<Byte> m)このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ乗算演算(*
)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MUL
, s, m)
とも同じです。- パラメータ:
e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- このベクトルの各レーンをスカラーに殺した結果
- 関連項目:
mul(Vector,VectorMask)
,broadcast(byte)
,mul(byte)
,VectorOperators.MUL
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
div
public final ByteVector div(Vector<Byte> v)このベクトルを2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
DIV
, v)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- 定義:
- クラス
Vector<Byte>
のdiv
- APIのノート:
- 除数がゼロの場合、
ArithmeticException
がスローされます。 - パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルを2番目の入力ベクトルで割った結果
- 関連項目:
Vector.div(Vector,VectorMask)
,DoubleVector.div(double)
,VectorOperators.DIV
,Vector.lanewise(VectorOperators.Binary,Vector)
,IntVector.lanewise(VectorOperators.Binary,int)
-
div
public final ByteVector div(byte e)このベクトルを入力スカラーのブロードキャストで除算します。 これは、プリミティブ分割演算(/
)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
DIV
, e)
とも同じです。- APIのノート:
- 除数がゼロの場合、
ArithmeticException
がスローされます。 - パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルの各レーンをスカラーで割った結果
- 関連項目:
div(Vector)
,broadcast(byte)
,div(byte,VectorMask)
,VectorOperators.DIV
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
div
public final ByteVector div(Vector<Byte> v, VectorMask<Byte> m)このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
DIV
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- 定義:
- クラス
Vector<Byte>
のdiv
- APIのノート:
- 除数がゼロの場合、
ArithmeticException
がスローされます。 - パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルを2番目の入力ベクトルで割った結果
- 関連項目:
div(byte,VectorMask)
-
div
public final ByteVector div(byte e, VectorMask<Byte> m)このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ分割演算(/
)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise
(
DIV
, s, m)
とも同じです。- APIのノート:
- 除数がゼロの場合、
ArithmeticException
がスローされます。 - パラメータ:
e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- このベクトルの各レーンをスカラーで割った結果
- 関連項目:
div(Vector,VectorMask)
,broadcast(byte)
,div(byte)
,VectorOperators.DIV
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,byte)
-
min
public final ByteVector min(Vector<Byte> v)このベクトルと2番目の入力ベクトルの小さい方を計算します。 これは、演算Math.min()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MIN
, v)
とも同じです。- 定義:
- クラス
Vector<Byte>
のmin
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン最小値
- 関連項目:
IntVector.min(int)
,VectorOperators.MIN
,Vector.lanewise(VectorOperators.Binary,Vector)
,Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)
-
min
public final ByteVector min(byte e)このベクトルの小さい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.min()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MIN
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルに指定されたスカラーを掛けた結果
- 関連項目:
min(Vector)
,broadcast(byte)
,VectorOperators.MIN
,lanewise(VectorOperators.Binary,byte,VectorMask)
-
max
public final ByteVector max(Vector<Byte> v)このベクトルと2番目の入力ベクトルの大きい方を計算します。 これは、演算Math.max()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MAX
, v)
とも同じです。これは、
add()
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。 サブクラスは、このメソッドの追加のスカラー・ブラ・ド キャスト・オーバーロードを定義します。- 定義:
- クラス
Vector<Byte>
のmax
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン方向の最大値
- 関連項目:
IntVector.max(int)
,VectorOperators.MAX
,Vector.lanewise(VectorOperators.Binary,Vector)
,Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)
-
max
public final ByteVector max(byte e)このベクトルの大きい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.max()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MAX
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルに指定されたスカラーを掛けた結果
- 関連項目:
max(Vector)
,broadcast(byte)
,VectorOperators.MAX
,lanewise(VectorOperators.Binary,byte,VectorMask)
-
and
public final ByteVector and(Vector<Byte> v)このベクトルと次の入力ベクトルのビット単位の論理積(&
)を計算します。 これは、プリミティブなビット単位の演算(&
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
AND
, v)
とも同じです。これは、
add
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと次の入力ベクトルのビット単位の
&
- 関連項目:
and(byte)
,or(Vector)
,not()
,VectorOperators.AND
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
and
public final ByteVector and(byte e)このベクトルとスカラーのビット単位の論理積(&
)を計算します。 これは、プリミティブなビット単位の演算(&
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
AND
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルとスカラーのビット単位の
&
- 関連項目:
and(Vector)
,VectorOperators.AND
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
or
public final ByteVector or(Vector<Byte> v)このベクトルと別の入力ベクトルのビット単位の論理和(|
)を計算します。 これは、プリミティブなビット単位または演算(|
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
AND
, v)
とも同じです。これは、
add
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと次の入力ベクトルのビット単位の
|
- 関連項目:
or(byte)
,and(Vector)
,not()
,VectorOperators.OR
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
or
public final ByteVector or(byte e)このベクトルとスカラーのビット単位の論理和(|
)を計算します。 これは、プリミティブなビット単位または演算(|
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
OR
, e)
とも同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルとスカラーのビット単位の
|
- 関連項目:
or(Vector)
,VectorOperators.OR
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
neg
public final ByteVector neg()- 定義:
- クラス
Vector<Byte>
のneg
- 戻り値:
- このベクトルの否定
- 関連項目:
VectorOperators.NEG
,Vector.lanewise(VectorOperators.Unary)
,Vector.lanewise(VectorOperators.Unary,VectorMask)
-
abs
public final ByteVector abs()- 定義:
- クラス
Vector<Byte>
のabs
- 戻り値:
- このベクトルの絶対値
- 関連項目:
VectorOperators.ABS
,Vector.lanewise(VectorOperators.Unary)
,Vector.lanewise(VectorOperators.Unary,VectorMask)
-
not
public final ByteVector not()このベクトルのビット単位の論理補数(~
)を計算します。 これは、プリミティブなビット単位の非演算(~
)を各レーン値に適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
NOT
)
とも同じです。これは、
add
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。- 戻り値:
- このベクトルのビット単位の補数
~
- 関連項目:
and(Vector)
,VectorOperators.NOT
,lanewise(VectorOperators.Unary,VectorMask)
-
eq
public final VectorMask<Byte> eq(Vector<Byte> v)このベクトルが別の入力ベクトルと等しいかどうかを判定します。 これは、プリミティブ等価演算(==
)を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.EQ, v)
と同じです。- 定義:
- クラス
Vector<Byte>
のeq
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルが2番目の入力ベクトルと等しいかどうかをレーンワイズ判定した結果のマスク
- 関連項目:
Vector.compare(VectorOperators.Comparison,Vector)
,VectorOperators.EQ
,Vector.equals(java.lang.Object)
-
eq
public final VectorMask<Byte> eq(byte e)このベクトルが入力スカラーと等しいかどうかを判定します。 これは、プリミティブ等価演算(==
)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.Comparison.EQ, e)
と同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルが
e
と等しいかどうかを判定する結果マスク - 関連項目:
compare(VectorOperators.Comparison,byte)
-
lt
public final VectorMask<Byte> lt(Vector<Byte> v)このベクトルが別の入力ベクトルより小さいかどうかを判定します。 これは、プリミティブなより小さい演算の(<
)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.LT, v)
と同じです。- 定義:
- クラス
Vector<Byte>
のlt
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルが2番目の入力ベクトルより小さい場合のレーンワイズ・テストのマスク結果
- 関連項目:
Vector.compare(VectorOperators.Comparison,Vector)
,VectorOperators.LT
-
lt
public final VectorMask<Byte> lt(byte e)このベクトルが入力スカラーより小さいかどうかを判定します。 これはレーンワイズ二項テスト演算で、(<
)より小さいプリミティブを各レーンに適用します。 結果はcompare(VectorOperators.LT, e)
と同じです。- パラメータ:
e
- 入力スカラー- 戻り値:
- このベクトルが入力スカラーより小さいかどうかを判定したマスク結果
- 関連項目:
compare(VectorOperators.Comparison,byte)
-
test
public abstract VectorMask<Byte> test(VectorOperators.Test op)指定された演算に従って、このベクトルのレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用するレーンワイズ単項テスト演算です。- 定義:
- クラス
Vector<Byte>
のtest
- パラメータ:
op
- レーン値のテストに使用される演算- 戻り値:
- 選択されたテスト演算子に従って、このベクトルのレーンをテストしたマスク結果
- 関連項目:
VectorOperators.Comparison
,Vector.test(VectorOperators.Test, VectorMask)
,Vector.compare(VectorOperators.Comparison, Vector)
-
test
public final VectorMask<Byte> test(VectorOperators.Test op, VectorMask<Byte> m)指定された演算に従って、このベクトルの選択されたレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用する、マスクされたレーンワイズ単項テスト演算です。 返される結果は、式test(op).and(m)
と同じです。- 定義:
- クラス
Vector<Byte>
のtest
- パラメータ:
op
- レーン値のテストに使用される演算m
- マスク制御レーンの選択- 戻り値:
- 選択されたテスト演算子に従って、マスクによって選択されたレーン内でのみ、このベクトルのレーンをテストしたマスク結果
- 関連項目:
Vector.test(VectorOperators.Test)
-
compare
public abstract VectorMask<Byte> compare(VectorOperators.Comparison op, Vector<Byte> v)指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。- 定義:
- クラス
Vector<Byte>
のcompare
- パラメータ:
op
- レーン値の比較に使用される演算v
- 2番目の入力ベクトル- 戻り値:
- 選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
- 関連項目:
Vector.eq(Vector)
,Vector.lt(Vector)
,VectorOperators.Comparison
,Vector.compare(VectorOperators.Comparison, Vector, VectorMask)
,Vector.test(VectorOperators.Test)
-
compare
public final VectorMask<Byte> compare(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,v).and(m)
と同じです。- 定義:
- クラス
Vector<Byte>
のcompare
- パラメータ:
op
- レーン値の比較に使用される演算v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
- 関連項目:
Vector.compare(VectorOperators.Comparison, Vector)
-
compare
public abstract VectorMask<Byte> compare(VectorOperators.Comparison op, byte e)指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、比較演算を各レーンに適用するレーンワイズ二項テスト演算です。結果は
compare(op, broadcast(species(), e))
と同じです。 つまり、スカラーは、同じ種のベクトルにブロードキャストされたとみなされ、選択された比較演算を使用して元のベクトルと比較されます。- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラー- 戻り値:
- 選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
- 関連項目:
compare(VectorOperators.Comparison,Vector)
,eq(byte)
,lt(byte)
-
compare
public final VectorMask<Byte> compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、対応するレーン値の各ペアに適用される、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,s).and(m)
と同じです。- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
- 関連項目:
compare(VectorOperators.Comparison,Vector,VectorMask)
-
compare
public abstract VectorMask<Byte> compare(VectorOperators.Comparison op, long e)指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、ブロードキャスト値とペアになっている各レーン値に特定の比較演算を適用するレーンワイズ二項テスト演算です。結果は
this.compare(op, this.broadcast(e))
と同じです。 つまり、スカラーは、同じ種のベクトルにブロードキャストされたとみなされ、選択された比較演算を使用して元のベクトルと比較されます。- 定義:
- クラス
Vector<Byte>
のcompare
- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラー- 戻り値:
- 選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
- 関連項目:
Vector.broadcast(long)
,Vector.compare(VectorOperators.Comparison,Vector)
-
compare
public final VectorMask<Byte> compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、指定された比較演算をブロードキャスト値とペアにして各レーン値に適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,e).and(m)
と同じです。- 定義:
- クラス
Vector<Byte>
のcompare
- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
- 関連項目:
Vector.broadcast(long)
,Vector.compare(VectorOperators.Comparison,Vector)
-
blend
public abstract ByteVector blend(Vector<Byte> v, VectorMask<Byte> 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);
-
addIndex
public abstract ByteVector 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);
-
blend
public final ByteVector blend(byte e, VectorMask<Byte> m)このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)
と同じです。- パラメータ:
e
- 置換レーン値を含む入力スカラーm
- スカラーのマスク制御レーンの選択- 戻り値:
- このベクトルのレーン要素をスカラー値とブレンドした結果
-
blend
public final ByteVector blend(long e, VectorMask<Byte> m)このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)
と同じです。 -
slice
public abstract ByteVector slice(int origin, Vector<Byte> 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
レーンの連続するスライス - 関連項目:
Vector.slice(int,Vector,VectorMask)
,Vector.slice(int)
,Vector.unslice(int,Vector,int)
-
slice
public final ByteVector slice(int origin, Vector<Byte> w, VectorMask<Byte> m)マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたorigin
レーンから開始し、(必要に応じて)を直後のベクトルに継続します。VLENGTH
レーンのブロックが独自のベクトルに抽出され、返されます。 結果のベクトルは、指定されたマスクで設定されていないすべてのレーンでゼロになります。 マスクに設定されたレーンには、this
またはv1
の選択したレーンからコピーされたデータが含まれます。これは、レーン要素を現在のベクトルと2番目のベクトルの間で正面に移動するクロス・レーン演算です。 どちらのベクトルも、スライスの抽出元となる長さ
2*VLENGTH
の結合"background"として表示できます。 返される結果は、式broadcast(0).blend(slice(origin,v1),m)
と同じです。- 定義:
- クラス
Vector<Byte>
のslice
- パラメータ:
origin
- スライスに転送する最初の入力レーンw
- スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトルm
- 結果のベクトルへのマスク制御レーンの選択- 戻り値:
- 指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得された
VLENGTH
レーンの連続するスライス - 関連項目:
Vector.slice(int,Vector)
,Vector.unslice(int,Vector,int,VectorMask)
-
slice
public abstract ByteVector slice(int origin)現在のベクトル内の指定されたorigin
レーンから始まる隣接レーンのセグメントをスライスします。VLENGTH
レーンのブロック(おそらくゼロのレーンが埋め込まれている)は、独自のベクトルに抽出されて返されます。 これは、ゼロ・レーンの拡張バックグラウンドに対して単一ベクトルからスライスする便利なメソッドです。 これは、slice
(origin,
broadcast
(0))
と同等です。 また、単に、ベクトルの終点にゼロが必要なレーンを埋めて、後のレーンから前のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はorigin
です。- パラメータ:
origin
- スライスに転送する最初の入力レーン- 戻り値:
- 出力の最初のレーンから始まり、末尾にゼロが埋め込まれた最後の
VLENGTH-origin
入力レーン - 関連項目:
Vector.slice(int,Vector)
,Vector.unslice(int,Vector,int)
-
unslice
public abstract ByteVector unslice(int origin, Vector<Byte> 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<Byte>
のunslice
- パラメータ:
origin
- スライスを受け取る最初の出力レーンw
- (2つのコピーとして)が挿入されたスライスを受け取るバックグラウンド・ベクトルpart
- 結果(ゼロまたは1つ)のパート番号- 戻り値:
- 指定された原点にこのベクトルを挿入して更新された、バックグラウンド・ベクトルのペア
w
の最初または2番目の部分 - 関連項目:
Vector.slice(int,Vector)
,Vector.unslice(int,Vector,int,VectorMask)
-
unslice
public abstract ByteVector unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。これは、現在のベクトルのレーン要素を前方に通し、そのレーン(マスクによって選択された場合)をバックグラウンド・ベクトルの論理ペアに挿入するクロス・レーン演算です。 このメソッドの「マスクされていないバージョン」と同様に、
part
番号で選択されたペアのいずれか一方のみが返されます。 マスクによって選択されたレーンN
ごとに、レーン値が最初のバックグラウンド・ベクトルのレーンorigin+N
にコピーされます(そのレーンが存在する場合)。それ以外の場合は、2番目のバックグラウンド・ベクトル(存在することが保証されています)のレーンorigin+N-VLENGTH
にコピーされます。 対応する入力レーンN
がマスクで設定解除されている場合、バックグラウンド・レーンは元の値を保持します。 挿入されたスライスのセット・レーンで更新された最初または2番目のバックグラウンド・ベクトルが返されます。part
の数値がゼロまたは1の場合は、最初または2番目に更新されたバックグラウンド・ベクトルが選択されます。- 定義:
- クラス
Vector<Byte>
のunslice
- パラメータ:
origin
- スライスを受け取る最初の出力レーンw
- 挿入されたスライスがm
で設定されている場合に、(2つのコピーとして)が受け取るバックグラウンド・ベクトルpart
- 結果(ゼロまたは1つ)のパート番号m
- 現在のベクトルからのマスク制御レーンの選択- 戻り値:
- 指定された原点にこのベクトルの選択されたレーンを挿入することで更新された、バックグラウンド・ベクトルのペア
w
の最初または2番目の部分 - 関連項目:
Vector.unslice(int,Vector,int)
,Vector.slice(int,Vector)
-
unslice
public abstract ByteVector unslice(int origin)slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。 他のunslice()
メソッドと比較して、このメソッドはバックグラウンド・ベクトルのペアの最初のメソッドのみを返します。 これは、unslice
(origin,
broadcast
(0), 0)
の結果を返す簡易メソッドです。 また、単に、ベクトルの始点で必要なレーンがゼロで塗りつぶされた、前のレーンから後のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はorigin
です。- 定義:
- クラス
Vector<Byte>
のunslice
- パラメータ:
origin
- スライスを受け取る最初の出力レーン- 戻り値:
- 指定された原点から始まり、先頭にゼロが埋め込まれた最初の
VLENGTH-origin
入力レーン - 関連項目:
Vector.unslice(int,Vector,int)
,Vector.slice(int)
-
rearrange
public abstract ByteVector rearrange(VectorShuffle<Byte> m)特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。 これは、このベクトルのレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンN
ごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)
ごとに、出力レーンN
はレーンI
の入力ベクトルから値を取得します。- 定義:
- クラス
Vector<Byte>
のrearrange
- パラメータ:
m
- シャッフル・コント・ローリング・レーン索引の選択- 戻り値:
- このベクトルのレーン要素の再配置
- 関連項目:
Vector.rearrange(VectorShuffle,VectorMask)
,Vector.rearrange(VectorShuffle,Vector)
,VectorShuffle.laneIsValid()
-
rearrange
public abstract ByteVector rearrange(VectorShuffle<Byte> s, VectorMask<Byte> 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<Byte>
のrearrange
- パラメータ:
s
- シャッフル・コント・ローリング・レーン索引の選択m
- シャッフルの適用を制御するマスク- 戻り値:
- このベクトルのレーン要素の再配置
- 関連項目:
Vector.rearrange(VectorShuffle)
,Vector.rearrange(VectorShuffle,Vector)
,VectorShuffle.laneIsValid()
-
rearrange
public abstract ByteVector rearrange(VectorShuffle<Byte> s, Vector<Byte> 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<Byte>
のrearrange
- パラメータ:
s
- 両方の入力ベクトルからのシャッフル制御レーンの選択v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン要素の再配置
- 関連項目:
Vector.rearrange(VectorShuffle)
,Vector.rearrange(VectorShuffle,VectorMask)
,VectorShuffle.laneIsValid()
,Vector.slice(int,Vector)
-
selectFrom
public abstract ByteVector selectFrom(Vector<Byte> v)このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 これは、このベクトルの制御下で引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 このベクトルのレーンN
ごと、およびこのベクトルのレーン値I=this.lane(N)
ごとに、出力レーンN
はレーンI
の引数ベクトルから値を取得します。 このようにすると、結果には引数ベクトルv
に格納されている値のみが含まれますが、this
の索引値に依存する順序で表示されます。 結果は、式v.rearrange(this.toShuffle())
と同じです。- 定義:
- クラス
Vector<Byte>
のselectFrom
- パラメータ:
v
- 結果値を提供するベクトル- 戻り値:
v
のレーン要素の再配置- 関連項目:
Vector.rearrange(VectorShuffle)
-
selectFrom
public abstract ByteVector selectFrom(Vector<Byte> s, VectorMask<Byte> m)このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。 このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 マスクで設定されていないレーンは、表からの値ではなくゼロを受け取ります。 これは、このベクトルとマスクの制御下で、引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 結果は、式v.rearrange(this.toShuffle(), m)
と同じです。- 定義:
- クラス
Vector<Byte>
のselectFrom
- パラメータ:
s
- 結果値を提供するベクトルm
-v
からの選択を制御するマスク- 戻り値:
v
のレーン要素の再配置- 関連項目:
Vector.selectFrom(Vector)
,Vector.rearrange(VectorShuffle,VectorMask)
-
bitwiseBlend
public final ByteVector bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)
を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise
(
BITWISE_BLEND
, bits, mask)
とも同じです。- パラメータ:
bits
- 現在のベクトルにブレンドする入力ビットmask
- 入力ビットのブレンドを可能にするビット単位のマスク- 戻り値:
- ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド
- 関連項目:
bitwiseBlend(byte,byte)
,bitwiseBlend(byte,Vector)
,bitwiseBlend(Vector,byte)
,VectorOperators.BITWISE_BLEND
,lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
-
bitwiseBlend
public final ByteVector bitwiseBlend(byte bits, byte mask)マスク・ビットを提供する別のスカラーの制御下にあるベクトルとスカラーのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)
を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise
(
BITWISE_BLEND
, bits, mask)
とも同じです。- パラメータ:
bits
- 現在のベクトルにブレンドする入力ビットmask
- 入力ビットのブレンドを可能にするビット単位のマスク- 戻り値:
- ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド
- 関連項目:
bitwiseBlend(Vector,Vector)
,VectorOperators.BITWISE_BLEND
,lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
-
bitwiseBlend
public final ByteVector bitwiseBlend(byte bits, Vector<Byte> mask)マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)
を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise
(
BITWISE_BLEND
, bits, mask)
とも同じです。- パラメータ:
bits
- 現在のベクトルにブレンドする入力ビットmask
- 入力ビットのブレンドを可能にするビット単位のマスク- 戻り値:
- ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド
- 関連項目:
bitwiseBlend(Vector,Vector)
,VectorOperators.BITWISE_BLEND
,lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)
-
bitwiseBlend
public final ByteVector bitwiseBlend(Vector<Byte> bits, byte mask)マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)
を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise
(
BITWISE_BLEND
, bits, mask)
とも同じです。- パラメータ:
bits
- 現在のベクトルにブレンドする入力ビットmask
- 入力ビットのブレンドを可能にするビット単位のマスク- 戻り値:
- ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド
- 関連項目:
bitwiseBlend(Vector,Vector)
,VectorOperators.BITWISE_BLEND
,lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
-
reduceLanes
public abstract byte reduceLanes(VectorOperators.Associative op)このベクトルのすべてのレーンから累積された値を返します。 これは、指定された演算をすべてのレーン要素に適用する、関連するクロス・レーン削減演算です。いくつかのリダクション演算はオペランドの任意の並替えをサポートしていませんが、有用性のためにここに含まれています。
-
FIRST_NONZERO
の場合、リダクションは最小番号のゼロ以外のレーンから値を返します。 - その他のリダクション演算はすべて、完全に可換的であり、連想的です。 実装では任意の処理順序を選択できますが、常に同じ結果が生成されます。
- パラメータ:
op
- レーン値を結合するために使用される演算- 戻り値:
- 累積結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
reduceLanes(VectorOperators.Associative,VectorMask)
,add(Vector)
,mul(Vector)
,min(Vector)
,max(Vector)
,and(Vector)
,or(Vector)
,VectorOperators.XOR
,VectorOperators.FIRST_NONZERO
-
-
reduceLanes
public abstract byte reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。 これは、指定した工程を選択したレーン要素に適用する、関連するクロス・レーン短縮演算です。要素が選択されていない場合は、演算固有のアイデンティティ値が返されます。
-
演算が
ADD
,XOR
,OR
またはFIRST_NONZERO
の場合、アイデンティティ値はゼロ(デフォルトのbyte
値)です。 -
演算が
MUL
の場合、アイデンティティ値はいずれかです。 -
演算が
AND
の場合、アイデンティティ値は単一の(すべてのビット・セット)を引いた値になります。 -
演算が
MAX
の場合、アイデンティティ値はByte.MIN_VALUE
です。 -
演算が
MIN
の場合、アイデンティティ値はByte.MAX_VALUE
です。
いくつかのリダクション演算はオペランドの任意の並替えをサポートしていませんが、有用性のためにここに含まれています。
-
FIRST_NONZERO
の場合、リダクションは最小番号のゼロ以外のレーンから値を返します。 - その他のリダクション演算はすべて、完全に可換的であり、連想的です。 実装では任意の処理順序を選択できますが、常に同じ結果が生成されます。
- パラメータ:
op
- レーン値を結合するために使用される演算m
- マスク制御レーンの選択- 戻り値:
- 選択されたレーン値から累積された還元結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
reduceLanes(VectorOperators.Associative)
-
演算が
-
lane
public abstract byte lane(int i)レーン索引i
のレーン要素を取得- パラメータ:
i
- レーンのインデックス- 戻り値:
- レーン索引
i
のレーン要素 - 例外:
IllegalArgumentException
- 索引が範囲外の(< 0 || >= length()
)の場合
-
withLane
public abstract ByteVector withLane(int i, byte e)レーン索引i
にあるこのベクトルのレーン要素を値e
に置き換えます。 これはクロス・レーン演算であり、このベクトルを、e
をブロードキャストした結果である入力ベクトルおよびレーン索引i
でレーンが1つのみ設定されているマスクとブレンドした結果を返すかのように動作します。- パラメータ:
i
- 置換されるレーン要素のレーン索引e
- 配置される値- 戻り値:
- レーン索引
i
にあるこのベクトルのレーン要素を値e
で置き換えた結果。 - 例外:
IllegalArgumentException
- 索引が範囲外の(< 0 || >= length()
)の場合
-
toArray
public final byte[] toArray()すべてのレーン値を含むbyte[]
型の配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素はレーン順に格納されます。このメソッドは、このベクトルを割り当てられた配列(
intoArray
を使用して)に格納する場合と同様に動作し、次のように配列を返します:byte[] a = new byte[this.length()]; this.intoArray(a, 0); return a;
- 定義:
- クラス
Vector<Byte>
のtoArray
- 戻り値:
- このベクトルのレーン値を含む配列
- 関連項目:
toArray()
,IntVector.toArray()
,DoubleVector.toArray()
-
toIntArray
public final int[] toIntArray()int
型に変換された、すべてのレーン値を含むint[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプがfloat
またはdouble
の場合、この演算は失敗する可能性があります。 ベクトル・レーン値がint
として表現できない場合は、例外がスローされます。- 定義:
- クラス
Vector<Byte>
のtoIntArray
- 実装上のノート:
- このメソッドを
ByteVector
型のベクトルで使用すると、精度や範囲が失われないため、UnsupportedOperationException
はスローされません。 - 戻り値:
- このベクトルのレーン値を含む
int[]
配列 - 関連項目:
Vector.toArray()
,Vector.toLongArray()
,Vector.toDoubleArray()
,IntVector.toArray()
-
toLongArray
public final long[] toLongArray()long
型に変換された、すべてのレーン値を含むlong[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプがfloat
またはdouble
の場合、この演算は失敗する可能性があります。 ベクトル・レーン値がlong
として表現できない場合は、例外がスローされます。- 定義:
- クラス
Vector<Byte>
のtoLongArray
- 実装上のノート:
- このメソッドを
ByteVector
型のベクトルで使用すると、精度や範囲が失われないため、UnsupportedOperationException
はスローされません。 - 戻り値:
- このベクトルのレーン値を含む
long[]
配列 - 関連項目:
Vector.toArray()
,Vector.toIntArray()
,Vector.toDoubleArray()
,LongVector.toArray()
-
toDoubleArray
public final double[] toDoubleArray()double
型に変換された、すべてのレーン値を含むdouble[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 ベクトル要素タイプがlong
の場合、この演算によって精度が失われる可能性があります。- 定義:
- クラス
Vector<Byte>
のtoDoubleArray
- 実装上のノート:
- このメソッドを
ByteVector
型のベクトルで使用すると、精度は失われません。 - 戻り値:
- このベクトルのレーン値を含む
double[]
配列。表現可能なdouble
値に丸められる可能性がある - 関連項目:
Vector.toArray()
,Vector.toIntArray()
,Vector.toLongArray()
,DoubleVector.toArray()
-
fromByteArray
public static ByteVector fromByteArray(VectorSpecies<Byte> 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 ByteVector fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)オフセットからマスクを使用してバイト配列からベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のbyte
(zero)が設定されます。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。このメソッドは、次のように
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 ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset)オフセットから始まるbyte[]
型の配列からベクトルをロードします。N
がベクトル・レーン索引であるベクトル・レーンごとに、索引offset + N
の配列要素がレーン索引N
の結果のベクトルに配置されます。- パラメータ:
species
- 希望するベクトルの種a
- 配列offset
- 配列へのオフセット- 戻り値:
- 配列からロードされたベクトル
- 例外:
IndexOutOfBoundsException
- ベクトル内のレーンN
のoffset+N < 0
またはoffset+N >= a.length
の場合
-
fromArray
public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)オフセットからマスクを使用して、byte[]
型の配列からベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のbyte
(zero)が設定されます。N
がベクトル・レーン索引であるベクトル・レーンごとに、索引N
のマスク・レーンが設定されている場合、索引offset + N
の配列要素はレーン索引N
の結果のベクトルに配置されます。それ以外の場合、デフォルトの要素値はレーン索引N
の結果のベクトルに配置されます。- パラメータ:
species
- 希望するベクトルの種a
- 配列offset
- 配列へのオフセットm
- マスク制御レーンの選択- 戻り値:
- 配列からロードされたベクトル
- 例外:
IndexOutOfBoundsException
- マスクが設定されているベクトル内のレーンN
のoffset+N < 0
またはoffset+N >= a.length
の場合
-
fromArray
public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用して、byte[]
タイプの配列から要素で構成される新しいベクトルを収集します。 索引マップは、指定された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
- 関連項目:
toIntArray()
-
fromArray
public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)マスクの制御下にあるbyte[]
型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定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
- 関連項目:
toIntArray()
-
fromByteBuffer
public static ByteVector fromByteBuffer(VectorSpecies<Byte> 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*1 < 0
またはoffset+N*1 >= bb.limit()
の場合
-
fromByteBuffer
public static ByteVector fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)オフセットからbyteバッファに開始し、マスクを使用して、byte bufferからベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のbyte
(zero)が設定されます。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。次の疑似コードは、この動作を示しています:
ByteBuffer eb = bb.duplicate() .position(offset); byte[] ar = new byte[species.length()]; for (int n = 0; n < ar.length; n++) { if (m.laneIsSet(n)) { ar[n] = eb.get(n); } } ByteVector r = ByteVector.fromArray(species, ar, 0);
- 実装上のノート:
- byte order引数は無視されます。
- パラメータ:
species
- 希望するベクトルの種bb
- byteバッファoffset
- byteバッファへのオフセットbo
- 目的のバイト・オーダーm
- マスク制御レーンの選択- 戻り値:
- byteバッファからロードされたベクトル
- 例外:
IndexOutOfBoundsException
- マスクが設定されているベクトル内のレーンN
のoffset+N*1 < 0
またはoffset+N*1 >= bb.limit()
の場合
-
intoArray
public final void intoArray(byte[] a, int offset)このベクトルをオフセットから始まるbyte[]
型の配列に格納します。N
がベクトル・レーン索引であるベクトル・レーンごとに、索引N
のレーン要素が配列要素a[offset+N]
に格納されます。- パラメータ:
a
-byte[]
型の配列offset
- 配列へのオフセット- 例外:
IndexOutOfBoundsException
- ベクトル内のレーンN
のoffset+N < 0
またはoffset+N >= a.length
の場合
-
intoArray
public final void intoArray(byte[] a, int offset, VectorMask<Byte> m)オフセットからマスクを使用して、このベクトルをbyte
の配列に格納します。N
がベクトル・レーン索引であるベクトル・レーンごとに、索引N
のレーン要素が配列要素a[offset+N]
に格納されます。N
のマスク・レーンが設定されていない場合、対応する配列要素a[offset+N]
は変更されません。配列範囲チェックは、マスクが設定されているレーンに対して実行されます。 マスクが設定されていないレーンは格納されず、
a
の正当な要素に対応する必要はありません。 つまり、未設定レーンは、ゼロ未満または配列の終わりを超える配列インデックスに対応している可能性があります。- パラメータ:
a
-byte[]
型の配列offset
- 配列へのオフセットm
- マスク制御レーンのストレージ- 例外:
IndexOutOfBoundsException
- マスクが設定されているベクトル内のレーンN
のoffset+N < 0
またはoffset+N >= a.length
の場合
-
intoArray
public final void intoArray(byte[] a, int offset, int[] indexMap, int mapOffset)「索引マップ」から一連のセカンダリ・オフセットに固定offset
を追加して取得した索引を使用して、このベクトルをbyte[]
型の配列に分散します。 索引マップは、指定された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
- 関連項目:
toIntArray()
-
intoArray
public final void intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)このベクトルを、マスクの制御下にあるbyte[]
型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定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
- 関連項目:
toIntArray()
-
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<Byte>
のintoByteArray
- パラメータ:
a
- バイト配列offset
- 配列へのオフセットbo
- 目的のバイト・オーダー
-
intoByteArray
public final void intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。
このメソッドは、次のように
intoByteBuffer()
をコールするかのように動作します:var bb = ByteBuffer.wrap(a); intoByteBuffer(bb, offset, bo, m);
- 定義:
- クラス
Vector<Byte>
の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<Byte>
のintoByteBuffer
- パラメータ:
bb
- byteバッファoffset
- 配列へのオフセットbo
- 目的のバイト・オーダー
-
intoByteBuffer
public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> 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<Byte>
のintoByteBuffer
- パラメータ:
bb
- byteバッファoffset
- 配列へのオフセットbo
- 目的のバイト・オーダーm
- マスク制御レーンの選択
-
reinterpretAsBytes
public final ByteVector reinterpretAsBytes()このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyte
では、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。 これは、式reinterpretShape(species().withLanes(byte.class))
の簡易メソッドです。 これは、Vector.reinterpretAsInts()
など、同じベクトル内の大きいレーンにバイトを統合する様々なメソッドとは逆であると考えられます。- 定義:
- クラス
Vector<Byte>
のreinterpretAsBytes
- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
ByteVector
- 関連項目:
Vector.reinterpretShape(VectorSpecies,int)
,IntVector.intoByteArray(byte[], int, ByteOrder)
,FloatVector.intoByteArray(byte[], int, ByteOrder)
,VectorSpecies.withLanes(Class)
-
viewAsIntegralLanes
public final ByteVector viewAsIntegralLanes()このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPE
またはVLENGTH
を変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPE
がすでに整数型である場合、同じベクトルが変更されずに返されます。 このメソッドは、この式の値を戻します:convert(conv,0)
。ここで、conv
はVectorOperators.Conversion.ofReinterpret(E.class,F.class)
で、F
はE
と同じサイズの非浮動小数点型です。- 定義:
- クラス
Vector<Byte>
のviewAsIntegralLanes
- 戻り値:
- 非浮動小数点として再解釈された、元のベクトル
- 関連項目:
VectorOperators.Conversion.ofReinterpret(Class,Class)
,Vector.convert(VectorOperators.Conversion,int)
-
viewAsFloatingLanes
public final Vector<?> viewAsFloatingLanes()このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPE
またはVLENGTH
を変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPE
がすでに浮動小数点型である場合、同じベクトルが変更されずに返されます。 ベクトル要素のサイズが浮動小数点型のサイズと一致しない場合は、IllegalArgumentException
がスローされます。 このメソッドは、この式の値を戻します:convert(conv,0)
。conv
はVectorOperators.Conversion.ofReinterpret(E.class,F.class)
で、F
はE
と同じサイズの浮動小数点型です(存在する場合)。- 定義:
- クラス
Vector<Byte>
のviewAsFloatingLanes
- 実装上のノート:
byte
と同じサイズの浮動小数点型がないため、このメソッドは常にUnsupportedOperationException
をスローします。 このメソッドの戻り型は、任意にVector<?>
として指定されます。 このAPIの将来のバージョンでは、追加の浮動小数点型が使用可能になった場合に戻り型が変更される可能性があります。- 戻り値:
- 浮動小数点として再解釈された、元のベクトル
- 関連項目:
VectorOperators.Conversion.ofReinterpret(Class,Class)
,Vector.convert(VectorOperators.Conversion,int)
-
toString
public final String toString()このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"
形式のこのベクトルの文字列表現を返します。 この文字列は、this.toArray()
から返されるbyte
配列に応じて、Arrays.toString()
へのコールによって生成されるかのように生成されます。 -
equals
public final boolean equals(Object obj)このベクトルが他のオブジェクトと同一かどうかを示します。 2つのベクトルは、同じ種と同じレーン値を同じ順序で持つ場合にのみ同一です。レーン値の比較は、両方のベクトルの
toArray()
によって返される配列に応じて、Arrays.equals()
をコールした場合と同様に生成されます。- 定義:
- クラス
Vector<Byte>
のequals
- パラメータ:
obj
- 比較対象の参照オブジェクト。- 戻り値:
- このベクトルがほかのオブジェクトと同一かどうか
- 関連項目:
Vector.eq(jdk.incubator.vector.Vector<E>)
-
hashCode
public final int hashCode()レーン値とベクトル種に基づいて、ベクトルのハッシュ・コード値を返します。- 定義:
- クラス
Vector<Byte>
のhashCode
- 戻り値:
- このベクトルのハッシュ・コード値
- 関連項目:
Object.equals(java.lang.Object)
,System.identityHashCode(java.lang.Object)
-
species
public final VectorSpecies<Byte> species()クラス:Vector
からコピーされた説明このベクトルの種を返します。 -
check
public final <F> Vector<F> check(VectorSpecies<F> species)クラス:Vector
からコピーされた説明このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。 効果は次の疑似コードのようになります :species == species() ? this : throw new ClassCastException()
。- 定義:
- クラス
Vector<E>
のcheck
- 型パラメータ:
F
- 必要な種のボックス化された要素型- パラメータ:
species
- 必要な種- 戻り値:
- 同じベクトル
- 関連項目:
Vector.check(Class)
,VectorMask.check(VectorSpecies)
,VectorShuffle.check(VectorSpecies)
-
check
このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。 効果は次の疑似コードのようになります :elementType == species().elementType() ? this : throw new ClassCastException()
。- 定義:
- クラス
Vector<E>
のcheck
- 型パラメータ:
F
- 必要なレーン型のボックス化された要素型- パラメータ:
elementType
- 必要なレーン・タイプ- 戻り値:
- 同じベクトル
- 関連項目:
VectorSpecies.check(Class)
,VectorMask.check(Class)
,Vector.check(VectorSpecies)
,VectorShuffle.check(VectorSpecies)
-
maskAll
public final VectorMask<Byte> maskAll(boolean bit)このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。このメソッドは、この式の値を戻します:
species().maskAll(bit)
。- 定義:
- クラス
Vector<E>
のmaskAll
- パラメータ:
bit
- 複製される指定されたマスク・ビット- 戻り値:
- 指定されたビットに従って各レーンが設定または設定解除されるマスク
- 関連項目:
VectorSpecies.maskAll(boolean)
-
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<Byte,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%を出力ベクトルのroomylong
レーンに変換するために、入力値の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
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルからシェイプおよび要素型によって変換されたベクトル
- 関連項目:
VectorOperators.I2L
,VectorOperators.Conversion.ofCast(Class,Class)
,VectorSpecies.partLimit(VectorSpecies,boolean)
,Vector.viewAsFloatingLanes()
,Vector.viewAsIntegralLanes()
,Vector.convertShape(VectorOperators.Conversion,VectorSpecies,int)
,Vector.reinterpretShape(VectorSpecies,int)
-
-
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
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルから要素型によって変換されたベクトル
- 関連項目:
VectorOperators.Conversion.ofCast(Class,Class)
,Vector.convertShape(VectorOperators.Conversion,VectorSpecies,int)
-
convertShape
public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Byte,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
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルから要素型によって変換されたベクトル
- 関連項目:
Vector.convert(VectorOperators.Conversion,int)
,Vector.castShape(VectorSpecies,int)
,Vector.reinterpretShape(VectorSpecies,int)
-