モジュール jdk.incubator.vector

パッケージ jdk.incubator.vector

クラスIntVector

java.lang.Object

jdk.incubator.vector.Vector<Integer>

jdk.incubator.vector.IntVector

public abstract class IntVector extends Vector<Integer>

順序付けられた不変のint値のシーケンスを表す特殊なVector。

フィールドのサマリー

フィールド

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

メソッドのサマリー

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

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

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

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

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

フィールド詳細

SPECIES_64

public static final VectorSpecies<Integer> SPECIES_64

VectorShape.S_64_BITのIntVectorを表す種。

SPECIES_128

public static final VectorSpecies<Integer> SPECIES_128

VectorShape.S_128_BITのIntVectorを表す種。

SPECIES_256

public static final VectorSpecies<Integer> SPECIES_256

VectorShape.S_256_BITのIntVectorを表す種。

SPECIES_512

public static final VectorSpecies<Integer> SPECIES_512

VectorShape.S_512_BITのIntVectorを表す種。

SPECIES_MAX

public static final VectorSpecies<Integer> SPECIES_MAX

VectorShape.S_Max_BITのIntVectorを表す種。

SPECIES_PREFERRED

public static final VectorSpecies<Integer> SPECIES_PREFERRED

IntVectorの優先種。 優先種はプラットフォームの最大ビット・サイズの一種です。

メソッドの詳細

zero

public static IntVector zero(VectorSpecies<Integer> species)

すべてのレーン要素がデフォルトのプリミティブ値であるゼロに設定されている、指定された種のベクトルを返します。

パラメータ:

species - 目的のゼロ・ベクトルの種

戻り値:

ゼロ・ベクトル

broadcast

public abstract IntVector broadcast(int e)

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

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

APIのノート:

スーパータイプVectorのbroadcast()という名前の同様のメソッドとは異なり、このメソッドはその引数を検証する必要はなく、IllegalArgumentExceptionをスローできません。 したがって、このメソッドはスーパータイプ・メソッドよりも推奨されます。

パラメータ:

e - ブロードキャストする値

戻り値:

すべてのレーン要素がプリミティブ値eに設定されているベクトル

関連項目:

• broadcast(VectorSpecies,long)
• Vector.broadcast(long)
• VectorSpecies.broadcast(long)

broadcast

public static IntVector broadcast(VectorSpecies<Integer> species, int e)

すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。

パラメータ:

species - 希望するベクトルの種

e - ブロードキャストする値

戻り値:

すべてのレーン要素がプリミティブ値eに設定されているベクトル

関連項目:

• broadcast(long)
• Vector.broadcast(long)
• VectorSpecies.broadcast(long)

broadcast

public abstract IntVector 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<Integer>のbroadcast

APIのノート:

IntVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.broadcast((int)e)。 この2つの式は、数値的に同一の結果を生成します。

パラメータ:

e - ブロードキャストする値

戻り値:

すべてのレーン要素がプリミティブ値eに設定されているベクトル

関連項目:

• VectorSpecies.broadcast(long)
• broadcast(int)
• FloatVector.broadcast(float)

broadcast

public static IntVector broadcast(VectorSpecies<Integer> species, long e)

すべてのレーン要素がプリミティブ値eに設定されている、指定された種のベクトルを返します。 long値は、e==(long)(ETYPE)eのようにベクトル種のETYPEで正確に表現できる必要があります。

パラメータ:

species - 希望するベクトルの種

e - ブロードキャストする値

戻り値:

すべてのレーン要素がプリミティブ値eに設定されているベクトル

例外:

IllegalArgumentException - 指定されたlong値をベクトルETYPEで表現できない場合

関連項目:

• broadcast(VectorSpecies,int)
• VectorSpecies.checkValue(long)

lanewise

public abstract IntVector lanewise(VectorOperators.Unary op)

このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。

定義:

クラスVector<Integer>の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 abstract IntVector lanewise(VectorOperators.Unary op, VectorMask<Integer> m)

マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。

定義:

クラスVector<Integer>のlanewise

パラメータ:

op - レーン値の処理に使用される演算

m - マスク制御レーンの選択

戻り値:

入力ベクトルにレーンワイズ演算を適用した結果

関連項目:

• Vector.lanewise(VectorOperators.Unary)

lanewise

public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v)

このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。

定義:

クラスVector<Integer>のlanewise

パラメータ:

op - レーン値を結合するために使用される演算

v - 入力ベクトル

戻り値:

2つの入力ベクトルにレーンワイズ演算を適用した結果

関連項目:

• lanewise(VectorOperators.Binary,int)
• lanewise(VectorOperators.Binary,int,VectorMask)

lanewise

public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)

このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。

定義:

クラスVector<Integer>のlanewise

パラメータ:

op - レーン値を結合するために使用される演算

v - 2番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

2つの入力ベクトルにレーンワイズ演算を適用した結果

関連項目:

• lanewise(VectorOperators.Binary,int,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Binary op, int e)

このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e))。

パラメータ:

op - レーン値の処理に使用される演算

e - 入力スカラー

戻り値:

2つの入力ベクトルにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)

このベクトルのレーン値とブロードキャスト・スカラーの値を、マスクによって制御されるレーン要素の選択と結合します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e), m)。

パラメータ:

op - レーン値の処理に使用される演算

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

入力ベクトルとスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Binary,Vector,VectorMask)
• lanewise(VectorOperators.Binary,int)

lanewise

public final IntVector lanewise(VectorOperators.Binary op, long e)

このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e))。

定義:

クラスVector<Integer>のlanewise

APIのノート:

IntVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.lanewise(op,(int)e)。 この2つの式は、数値的に同一の結果を生成します。

パラメータ:

op - レーン値を結合するために使用される演算

e - 入力スカラー

戻り値:

入力ベクトルとスカラーにレーンワイズ演算を適用した結果

関連項目:

• Vector.broadcast(long)
• Vector.lanewise(VectorOperators.Binary,long,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)

このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 2番目のオペランドはブロードキャスト整数値です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e), m)。

定義:

クラスVector<Integer>のlanewise

APIのノート:

IntVectorなどのVectorサブタイプを使用する場合は、通常、「より強い型指定のメソッド」が選択されます。 キャストを使用して明示的に選択できます: v.lanewise(op,(int)e,m)。 この2つの式は、数値的に同一の結果を生成します。

パラメータ:

op - レーン値を結合するために使用される演算

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

入力ベクトルとスカラーにレーンワイズ演算を適用した結果

関連項目:

• Vector.broadcast(long)
• Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)

lanewise

public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)

このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。 これは、選択した演算を各レーンに適用するレーンワイズの三項演算です。

定義:

クラスVector<Integer>のlanewise

パラメータ:

op - レーン値を結合するために使用される演算

v1 - 2番目の入力ベクトル

v2 - 3番目の入力ベクトル

戻り値:

3つの入力ベクトルに演算レーンワイズを適用した結果

関連項目:

• lanewise(VectorOperators.Ternary,int,int,VectorMask)
• lanewise(VectorOperators.Ternary,Vector,int,VectorMask)
• lanewise(VectorOperators.Ternary,int,Vector,VectorMask)
• lanewise(VectorOperators.Ternary,int,int)
• lanewise(VectorOperators.Ternary,Vector,int)
• lanewise(VectorOperators.Ternary,int,Vector)

lanewise

public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)

このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。

定義:

クラスVector<Integer>のlanewise

パラメータ:

op - レーン値を結合するために使用される演算

v1 - 2番目の入力ベクトル

v2 - 3番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

3つの入力ベクトルに演算レーンワイズを適用した結果

関連項目:

• lanewise(VectorOperators.Ternary,int,int,VectorMask)
• lanewise(VectorOperators.Ternary,Vector,int,VectorMask)
• lanewise(VectorOperators.Ternary,int,Vector,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2)

このベクトルのレーンの値を2つのブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), this.broadcast(e2))。

パラメータ:

op - レーン値を結合するために使用される演算

e1 - 最初の入力スカラー

e2 - 2番目の入力スカラー

戻り値:

入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Ternary,Vector,Vector)
• lanewise(VectorOperators.Ternary,int,int,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> 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,int,int)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)

このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, v1, this.broadcast(e2))。

パラメータ:

op - レーン値を結合するために使用される演算

v1 - その他の入力ベクトル

e2 - 入力スカラー

戻り値:

入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Ternary,int,int)
• lanewise(VectorOperators.Ternary,Vector,int,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)

このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, v1, this.broadcast(e2), m)。

パラメータ:

op - レーン値を結合するために使用される演算

v1 - その他の入力ベクトル

e2 - 入力スカラー

m - マスク制御レーンの選択

戻り値:

入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Ternary,Vector,Vector)
• lanewise(VectorOperators.Ternary,int,int,VectorMask)
• lanewise(VectorOperators.Ternary,Vector,int)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)

このベクトルのレーンの値を、別のベクトルおよびブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), v2)。

パラメータ:

op - レーン値を結合するために使用される演算

e1 - 入力スカラー

v2 - その他の入力ベクトル

戻り値:

入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Ternary,Vector,Vector)
• lanewise(VectorOperators.Ternary,int,Vector,VectorMask)

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)

このベクトルのレーン値を別のベクトルおよびブロードキャスト・スカラーの値と結合し、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用する、マスクされたレーンワイズ三項演算です。 戻り値はこの式と等しくなります: this.lanewise(op, this.broadcast(e1), v2, m)。

パラメータ:

op - レーン値を結合するために使用される演算

e1 - 入力スカラー

v2 - その他の入力ベクトル

m - マスク制御レーンの選択

戻り値:

入力ベクトルおよびスカラーにレーンワイズ演算を適用した結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
• lanewise(VectorOperators.Ternary,int,Vector)

add

public final IntVector add(Vector<Integer> v)

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

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

定義:

クラスVector<Integer>のadd

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルを2番目の入力ベクトルに加算した結果

関連項目:

• add(int)

add

public final IntVector add(int e)

このベクトルを入力スカラーのブロードキャストに追加します。 これは、プリミティブ加算演算(+)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( ADD, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルの各レーンをスカラーに加算した結果

関連項目:

• add(Vector)
• broadcast(int)
• add(int,VectorMask)
• VectorOperators.ADD
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

add

public final IntVector add(Vector<Integer> v, VectorMask<Integer> m)

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

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

定義:

クラスVector<Integer>のadd

パラメータ:

v - 2番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

指定されたベクトルにこのベクトルを追加した結果

関連項目:

• add(int,VectorMask)

add

public final IntVector add(int e, VectorMask<Integer> m)

このベクトルを入力スカラーのブロードキャストに追加し、マスクによって制御されるレーン要素を選択します。 これは、各レーンにプリミティブ加算演算(+)を適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( ADD, s, m)とも同じです。

パラメータ:

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

このベクトルの各レーンをスカラーに加算した結果

関連項目:

• add(Vector,VectorMask)
• broadcast(int)
• add(int)
• VectorOperators.ADD
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

sub

public final IntVector sub(Vector<Integer> v)

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

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

定義:

クラスVector<Integer>のsub

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルから2番目の入力ベクトルを減算した結果

関連項目:

• sub(int)

sub

public final IntVector sub(int e)

このベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( SUB, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルの各レーンからスカラーを減算した結果

関連項目:

• sub(Vector)
• broadcast(int)
• sub(int,VectorMask)
• VectorOperators.SUB
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

sub

public final IntVector sub(Vector<Integer> v, VectorMask<Integer> m)

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

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

定義:

クラスVector<Integer>のsub

パラメータ:

v - 2番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

このベクトルから2番目の入力ベクトルを減算した結果

関連項目:

• sub(int,VectorMask)

sub

public final IntVector sub(int e, VectorMask<Integer> m)

マスクの制御下にあるこのベクトルから入力スカラーを減算します。 これは、プリミティブ減算演算(-)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( SUB, s, m)とも同じです。

パラメータ:

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

このベクトルの各レーンからスカラーを減算した結果

関連項目:

• sub(Vector,VectorMask)
• broadcast(int)
• sub(int)
• VectorOperators.SUB
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

mul

public final IntVector mul(Vector<Integer> v)

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

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

定義:

クラスVector<Integer>のmul

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルに2番目の入力ベクトルを掛けた結果

関連項目:

• mul(int)

mul

public final IntVector mul(int e)

このベクトルに入力スカラーのブロードキャストを掛けます。 これは、プリミティブ乗算演算(*)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MUL, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルに指定されたスカラーを掛けた結果

関連項目:

• mul(Vector)
• broadcast(int)
• mul(int,VectorMask)
• VectorOperators.MUL
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

mul

public final IntVector mul(Vector<Integer> v, VectorMask<Integer> m)

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

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

定義:

クラスVector<Integer>のmul

パラメータ:

v - 2番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

このベクトルに指定されたベクトルを掛けた結果

関連項目:

• mul(int,VectorMask)

mul

public final IntVector mul(int e, VectorMask<Integer> m)

このベクトルに入力スカラーのブロードキャストを掛け、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ乗算演算(*)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( MUL, s, m)とも同じです。

パラメータ:

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

このベクトルの各レーンをスカラーに殺した結果

関連項目:

• mul(Vector,VectorMask)
• broadcast(int)
• mul(int)
• VectorOperators.MUL
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

div

public final IntVector div(Vector<Integer> v)

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

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

定義:

クラスVector<Integer>のdiv

APIのノート:

除数がゼロの場合、 ArithmeticExceptionがスローされます。

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルを2番目の入力ベクトルで割った結果

関連項目:

• Vector.div(Vector,VectorMask)
• DoubleVector.div(double)
• VectorOperators.DIV
• Vector.lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

div

public final IntVector div(int e)

このベクトルを入力スカラーのブロードキャストで除算します。 これは、プリミティブ分割演算(/)を各レーンに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( DIV, e)とも同じです。

APIのノート:

除数がゼロの場合、 ArithmeticExceptionがスローされます。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルの各レーンをスカラーで割った結果

関連項目:

• div(Vector)
• broadcast(int)
• div(int,VectorMask)
• VectorOperators.DIV
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

div

public final IntVector div(Vector<Integer> v, VectorMask<Integer> m)

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

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

定義:

クラスVector<Integer>のdiv

APIのノート:

除数がゼロの場合、 ArithmeticExceptionがスローされます。

パラメータ:

v - 2番目の入力ベクトル

m - マスク制御レーンの選択

戻り値:

このベクトルを2番目の入力ベクトルで割った結果

関連項目:

• div(int,VectorMask)

div

public final IntVector div(int e, VectorMask<Integer> m)

このベクトルを入力スカラーのブロードキャストで除算し、マスクによって制御されるレーン要素を選択します。 これは、プリミティブ分割演算(/)を各レーンに適用する、マスクされたレーンワイズ二項演算です。 このメソッドは、式lanewise( DIV, s, m)とも同じです。

APIのノート:

除数がゼロの場合、 ArithmeticExceptionがスローされます。

パラメータ:

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

このベクトルの各レーンをスカラーで割った結果

関連項目:

• div(Vector,VectorMask)
• broadcast(int)
• div(int)
• VectorOperators.DIV
• lanewise(VectorOperators.Binary,Vector)
• lanewise(VectorOperators.Binary,int)

min

public final IntVector min(Vector<Integer> v)

このベクトルと2番目の入力ベクトルの小さい方を計算します。 これは、演算Math.min()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MIN, v)とも同じです。

定義:

クラスVector<Integer>のmin

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルと2番目の入力ベクトルのレーン最小値

関連項目:

• min(int)
• VectorOperators.MIN
• Vector.lanewise(VectorOperators.Binary,Vector)
• Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)

min

public final IntVector min(int e)

このベクトルの小さい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.min()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MIN, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルに指定されたスカラーを掛けた結果

関連項目:

• min(Vector)
• broadcast(int)
• VectorOperators.MIN
• lanewise(VectorOperators.Binary,int,VectorMask)

max

public final IntVector max(Vector<Integer> v)

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

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

定義:

クラスVector<Integer>のmax

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルと2番目の入力ベクトルのレーン方向の最大値

関連項目:

• max(int)
• VectorOperators.MAX
• Vector.lanewise(VectorOperators.Binary,Vector)
• Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)

max

public final IntVector max(int e)

このベクトルの大きい方と入力スカラーのブロードキャストを計算します。 これは、演算Math.max()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MAX, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルに指定されたスカラーを掛けた結果

関連項目:

• max(Vector)
• broadcast(int)
• VectorOperators.MAX
• lanewise(VectorOperators.Binary,int,VectorMask)

and

public final IntVector and(Vector<Integer> v)

このベクトルと次の入力ベクトルのビット単位の論理積(&)を計算します。 これは、プリミティブなビット単位の演算(&)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( AND, v)とも同じです。

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

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルと次の入力ベクトルのビット単位の&

関連項目:

• and(int)
• or(Vector)
• not()
• VectorOperators.AND
• lanewise(VectorOperators.Binary,Vector,VectorMask)

and

public final IntVector and(int e)

このベクトルとスカラーのビット単位の論理積(&)を計算します。 これは、プリミティブなビット単位の演算(&)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( AND, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルとスカラーのビット単位の&

関連項目:

• and(Vector)
• VectorOperators.AND
• lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final IntVector or(Vector<Integer> v)

このベクトルと別の入力ベクトルのビット単位の論理和(|)を計算します。 これは、プリミティブなビット単位または演算(|)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( AND, v)とも同じです。

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

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルと次の入力ベクトルのビット単位の|

関連項目:

• or(int)
• and(Vector)
• not()
• VectorOperators.OR
• lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final IntVector or(int e)

このベクトルとスカラーのビット単位の論理和(|)を計算します。 これは、プリミティブなビット単位または演算(|)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( OR, e)とも同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルとスカラーのビット単位の|

関連項目:

• or(Vector)
• VectorOperators.OR
• lanewise(VectorOperators.Binary,Vector,VectorMask)

neg

public final IntVector neg()

このベクトルを否定します。 これは、プリミティブ否定演算(-x)を各入力レーンに適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( NEG)とも同じです。

定義:

クラスVector<Integer>のneg

戻り値:

このベクトルの否定

関連項目:

• VectorOperators.NEG
• Vector.lanewise(VectorOperators.Unary)
• Vector.lanewise(VectorOperators.Unary,VectorMask)

abs

public final IntVector abs()

このベクトルの絶対値を返します。 これは、各入力レーンにメソッドMath.absを適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( ABS)とも同じです。

定義:

クラスVector<Integer>のabs

戻り値:

このベクトルの絶対値

関連項目:

• VectorOperators.ABS
• Vector.lanewise(VectorOperators.Unary)
• Vector.lanewise(VectorOperators.Unary,VectorMask)

not

public final IntVector not()

このベクトルのビット単位の論理補数(~)を計算します。 これは、プリミティブなビット単位の非演算(~)を各レーン値に適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( NOT)とも同じです。

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

戻り値:

このベクトルのビット単位の補数~

関連項目:

• and(Vector)
• VectorOperators.NOT
• lanewise(VectorOperators.Unary,VectorMask)

eq

public final VectorMask<Integer> eq(Vector<Integer> v)

このベクトルが別の入力ベクトルと等しいかどうかを判定します。 これは、プリミティブ等価演算(==)を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.EQ, v)と同じです。

定義:

クラスVector<Integer>のeq

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルが2番目の入力ベクトルと等しいかどうかをレーンワイズ判定した結果のマスク

関連項目:

• Vector.compare(VectorOperators.Comparison,Vector)
• VectorOperators.EQ
• Vector.equals(java.lang.Object)

eq

public final VectorMask<Integer> eq(int e)

このベクトルが入力スカラーと等しいかどうかを判定します。 これは、プリミティブ等価演算(==)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.Comparison.EQ, e)と同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルがeと等しいかどうかを判定する結果マスク

関連項目:

• compare(VectorOperators.Comparison,int)

lt

public final VectorMask<Integer> lt(Vector<Integer> v)

このベクトルが別の入力ベクトルより小さいかどうかを判定します。 これは、プリミティブなより小さい演算の(<)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.LT, v)と同じです。

定義:

クラスVector<Integer>のlt

パラメータ:

v - 2番目の入力ベクトル

戻り値:

このベクトルが2番目の入力ベクトルより小さい場合のレーンワイズ・テストのマスク結果

関連項目:

• Vector.compare(VectorOperators.Comparison,Vector)
• VectorOperators.LT

lt

public final VectorMask<Integer> lt(int e)

このベクトルが入力スカラーより小さいかどうかを判定します。 これはレーンワイズ二項テスト演算で、(<)より小さいプリミティブを各レーンに適用します。 結果はcompare(VectorOperators.LT, e)と同じです。

パラメータ:

e - 入力スカラー

戻り値:

このベクトルが入力スカラーより小さいかどうかを判定したマスク結果

関連項目:

• compare(VectorOperators.Comparison,int)

test

public abstract VectorMask<Integer> test(VectorOperators.Test op)

指定された演算に従って、このベクトルのレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用するレーンワイズ単項テスト演算です。

定義:

クラスVector<Integer>のtest

パラメータ:

op - レーン値のテストに使用される演算

戻り値:

選択されたテスト演算子に従って、このベクトルのレーンをテストしたマスク結果

関連項目:

• VectorOperators.Comparison
• Vector.test(VectorOperators.Test, VectorMask)
• Vector.compare(VectorOperators.Comparison, Vector)

test

public abstract VectorMask<Integer> test(VectorOperators.Test op, VectorMask<Integer> m)

指定された演算に従って、このベクトルの選択されたレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用する、マスクされたレーンワイズ単項テスト演算です。 返される結果は、式test(op).and(m)と同じです。

定義:

クラスVector<Integer>のtest

パラメータ:

op - レーン値のテストに使用される演算

m - マスク制御レーンの選択

戻り値:

選択されたテスト演算子に従って、マスクによって選択されたレーン内でのみ、このベクトルのレーンをテストしたマスク結果

関連項目:

• Vector.test(VectorOperators.Test)

compare

public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, Vector<Integer> v)

指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。

定義:

クラスVector<Integer>のcompare

パラメータ:

op - レーン値の比較に使用される演算

v - 2番目の入力ベクトル

戻り値:

選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果

関連項目:

• Vector.eq(Vector)
• Vector.lt(Vector)
• VectorOperators.Comparison
• Vector.compare(VectorOperators.Comparison, Vector, VectorMask)
• Vector.test(VectorOperators.Test)

compare

public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, int e)

指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、比較演算を各レーンに適用するレーンワイズ二項テスト演算です。

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

パラメータ:

op - レーン値の比較に使用される演算

e - 入力スカラー

戻り値:

選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果

関連項目:

• compare(VectorOperators.Comparison,Vector)
• eq(int)
• lt(int)

compare

public final VectorMask<Integer> compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)

指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、対応するレーン値の各ペアに適用される、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,s).and(m)と同じです。

パラメータ:

op - レーン値の比較に使用される演算

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果

関連項目:

• Vector.compare(VectorOperators.Comparison,Vector,VectorMask)

compare

public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, long e)

指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、ブロードキャスト値とペアになっている各レーン値に特定の比較演算を適用するレーンワイズ二項テスト演算です。

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

定義:

クラスVector<Integer>のcompare

パラメータ:

op - レーン値の比較に使用される演算

e - 入力スカラー

戻り値:

選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果

関連項目:

• Vector.broadcast(long)
• Vector.compare(VectorOperators.Comparison,Vector)

compare

public final VectorMask<Integer> compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)

指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、指定された比較演算をブロードキャスト値とペアにして各レーン値に適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,e).and(m)と同じです。

定義:

クラスVector<Integer>のcompare

パラメータ:

op - レーン値の比較に使用される演算

e - 入力スカラー

m - マスク制御レーンの選択

戻り値:

選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果

関連項目:

• Vector.broadcast(long)
• Vector.compare(VectorOperators.Comparison,Vector)

blend

public abstract IntVector blend(Vector<Integer> v, VectorMask<Integer> 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<Integer>のblend

パラメータ:

v - 置換レーン値を含む2番目の入力ベクトル

m - 2番目の入力ベクトルからのマスク制御レーンの選択

戻り値:

このベクトルのレーン要素を2番目の入力ベクトルのレーン要素とブレンドした結果

addIndex

public abstract IntVector 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<Integer>のaddIndex

パラメータ:

scale - 各レーン索引Nで乗算する数(通常は1)

戻り値:

scaleによってスケーリングされた、各レーン要素を対応するレーン索引Nで増分した結果

blend

public final IntVector blend(int e, VectorMask<Integer> m)

このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)と同じです。

パラメータ:

e - 置換レーン値を含む入力スカラー

m - スカラーのマスク制御レーンの選択

戻り値:

このベクトルのレーン要素をスカラー値とブレンドした結果

blend

public final IntVector blend(long e, VectorMask<Integer> m)

このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)と同じです。

定義:

クラスVector<Integer>のblend

パラメータ:

e - 置換レーン値を含む入力スカラー

m - スカラーのマスク制御レーンの選択

戻り値:

このベクトルのレーン要素をスカラー値とブレンドした結果

slice

public abstract IntVector slice(int origin, Vector<Integer> 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 IntVector slice(int origin, Vector<Integer> w, VectorMask<Integer> m)

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

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

定義:

クラスVector<Integer>のslice

パラメータ:

origin - スライスに転送する最初の入力レーン

w - スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトル

m - 結果のベクトルへのマスク制御レーンの選択

戻り値:

指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得されたVLENGTHレーンの連続するスライス

関連項目:

• Vector.slice(int,Vector)
• Vector.unslice(int,Vector,int,VectorMask)

slice

public abstract IntVector 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 IntVector unslice(int origin, Vector<Integer> 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<Integer>のunslice

パラメータ:

origin - スライスを受け取る最初の出力レーン

w - (2つのコピーとして)が挿入されたスライスを受け取るバックグラウンド・ベクトル

part - 結果(ゼロまたは1つ)のパート番号

戻り値:

指定された原点にこのベクトルを挿入して更新された、バックグラウンド・ベクトルのペアwの最初または2番目の部分

関連項目:

• Vector.slice(int,Vector)
• Vector.unslice(int,Vector,int,VectorMask)

unslice

public abstract IntVector unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)

slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。

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

定義:

クラスVector<Integer>のunslice

パラメータ:

origin - スライスを受け取る最初の出力レーン

w - 挿入されたスライスがmで設定されている場合に、(2つのコピーとして)が受け取るバックグラウンド・ベクトル

part - 結果(ゼロまたは1つ)のパート番号

m - 現在のベクトルからのマスク制御レーンの選択

戻り値:

指定された原点にこのベクトルの選択されたレーンを挿入することで更新された、バックグラウンド・ベクトルのペアwの最初または2番目の部分

関連項目:

• Vector.unslice(int,Vector,int)
• Vector.slice(int,Vector)

unslice

public abstract IntVector unslice(int origin)

slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。 他のunslice()メソッドと比較して、このメソッドはバックグラウンド・ベクトルのペアの最初のメソッドのみを返します。 これは、unslice (origin, broadcast(0), 0)の結果を返す簡易メソッドです。 また、単に、ベクトルの始点で必要なレーンがゼロで塗りつぶされた、前のレーンから後のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はoriginです。

定義:

クラスVector<Integer>のunslice

パラメータ:

origin - スライスを受け取る最初の出力レーン

戻り値:

指定された原点から始まり、先頭にゼロが埋め込まれた最初のVLENGTH-origin入力レーン

関連項目:

• Vector.unslice(int,Vector,int)
• Vector.slice(int)

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> m)

特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。 これは、このベクトルのレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンNごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)ごとに、出力レーンNはレーンIの入力ベクトルから値を取得します。

定義:

クラスVector<Integer>のrearrange

パラメータ:

m - シャッフル・コント・ローリング・レーン索引の選択

戻り値:

このベクトルのレーン要素の再配置

関連項目:

• Vector.rearrange(VectorShuffle,VectorMask)
• Vector.rearrange(VectorShuffle,Vector)
• VectorShuffle.laneIsValid()

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> s, VectorMask<Integer> 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<Integer>のrearrange

パラメータ:

s - シャッフル・コント・ローリング・レーン索引の選択

m - シャッフルの適用を制御するマスク

戻り値:

このベクトルのレーン要素の再配置

関連項目:

• Vector.rearrange(VectorShuffle)
• Vector.rearrange(VectorShuffle,Vector)
• VectorShuffle.laneIsValid()

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> s, Vector<Integer> 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<Integer>のrearrange

パラメータ:

s - 両方の入力ベクトルからのシャッフル制御レーンの選択

v - 2番目の入力ベクトル

戻り値:

このベクトルと2番目の入力ベクトルのレーン要素の再配置

関連項目:

• Vector.rearrange(VectorShuffle)
• Vector.rearrange(VectorShuffle,VectorMask)
• VectorShuffle.laneIsValid()
• Vector.slice(int,Vector)

compress

public abstract IntVector compress(VectorMask<Integer> m)

特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。 これは、指定されたマスクによって選択されたこのベクトルのレーン要素を圧縮するクロス・レーン演算です。 マスクの各レーンNについて、レーンNのマスクが設定されている場合、入力ベクトルのレーンNの要素が選択され、レーン0から開始して連続して出力ベクトルに格納されます。 出力ベクトルの残りのレーンがある場合は、すべてゼロに設定されます。

定義:

クラスVector<Integer>のcompress

パラメータ:

m - 圧縮を制御するマスク

戻り値:

このベクトルの圧縮レーン要素

導入されたバージョン:

19

expand

public abstract IntVector expand(VectorMask<Integer> m)

このベクトルのレーン要素を特定のマスクの制御下で展開します。 これは、このベクトルの連続するレーン要素を、指定されたマスクによって選択された出力ベクトルのレーンに拡張するクロス・レーン演算です。 マスクの各レーンNについて、レーンNのマスクが設定されている場合、レーン0から始まる入力ベクトルの次の連続した要素が選択され、レーンNの出力ベクトルに格納されます。 出力ベクトルの残りのレーン(ある場合)はすべてゼロに設定されます。

定義:

クラスVector<Integer>のexpand

パラメータ:

m - 圧縮を制御するマスク

戻り値:

このベクトルの展開されたレーン要素

導入されたバージョン:

19

selectFrom

public abstract IntVector selectFrom(Vector<Integer> v)

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

定義:

クラスVector<Integer>のselectFrom

パラメータ:

v - 結果値を提供するベクトル

戻り値:

vのレーン要素の再配置

関連項目:

• Vector.rearrange(VectorShuffle)

selectFrom

public abstract IntVector selectFrom(Vector<Integer> s, VectorMask<Integer> m)

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

定義:

クラスVector<Integer>のselectFrom

パラメータ:

s - 結果値を提供するベクトル

m - vからの選択を制御するマスク

戻り値:

vのレーン要素の再配置

関連項目:

• Vector.selectFrom(Vector)
• Vector.rearrange(VectorShuffle,VectorMask)

bitwiseBlend

public final IntVector bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)

マスク・ビットを提供する3番目のベクトルの制御下にある2つのベクトルのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise( BITWISE_BLEND, bits, mask)とも同じです。

パラメータ:

bits - 現在のベクトルにブレンドする入力ビット

mask - 入力ビットのブレンドを可能にするビット単位のマスク

戻り値:

ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド

関連項目:

• bitwiseBlend(int,int)
• bitwiseBlend(int,Vector)
• bitwiseBlend(Vector,int)
• VectorOperators.BITWISE_BLEND
• lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)

bitwiseBlend

public final IntVector bitwiseBlend(int bits, int mask)

マスク・ビットを提供する別のスカラーの制御下にあるベクトルとスカラーのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise( BITWISE_BLEND, bits, mask)とも同じです。

パラメータ:

bits - 現在のベクトルにブレンドする入力ビット

mask - 入力ビットのブレンドを可能にするビット単位のマスク

戻り値:

ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド

関連項目:

• bitwiseBlend(Vector,Vector)
• VectorOperators.BITWISE_BLEND
• lanewise(VectorOperators.Ternary,int,int,VectorMask)

bitwiseBlend

public final IntVector bitwiseBlend(int bits, Vector<Integer> mask)

マスク・ビットを提供する別のベクトルの制御下にあるベクトルとスカラーのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise( BITWISE_BLEND, bits, mask)とも同じです。

パラメータ:

bits - 現在のベクトルにブレンドする入力ビット

mask - 入力ビットのブレンドを可能にするビット単位のマスク

戻り値:

ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド

関連項目:

• bitwiseBlend(Vector,Vector)
• VectorOperators.BITWISE_BLEND
• lanewise(VectorOperators.Ternary,int,Vector,VectorMask)

bitwiseBlend

public final IntVector bitwiseBlend(Vector<Integer> bits, int mask)

マスク・ビットを提供するスカラーの制御下にある2つのベクトルのビットをブレンドします。 これは、各レーンに対してビット単位のブレンド演算(a&~c)|(b&c)を実行するレーンワイズ三項演算です。 このメソッドは、式lanewise( BITWISE_BLEND, bits, mask)とも同じです。

パラメータ:

bits - 現在のベクトルにブレンドする入力ビット

mask - 入力ビットのブレンドを可能にするビット単位のマスク

戻り値:

ビット単位マスクの制御下にある、指定されたビットの現在のベクトルへのビット単位のブレンド

関連項目:

• bitwiseBlend(Vector,Vector)
• VectorOperators.BITWISE_BLEND
• lanewise(VectorOperators.Ternary,Vector,int,VectorMask)

reduceLanes

public abstract int 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 int reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)

マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。 これは、指定した工程を選択したレーン要素に適用する、関連するクロス・レーン短縮演算です。

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

• 演算がADD, XOR, ORまたはFIRST_NONZEROの場合、アイデンティティ値はゼロ(デフォルトのint値)です。
• 演算がMULの場合、アイデンティティ値はいずれかです。
• 演算がANDの場合、アイデンティティ値は単一の(すべてのビット・セット)を引いた値になります。
• 演算がMAXの場合、アイデンティティ値はInteger.MIN_VALUEです。
• 演算がMINの場合、アイデンティティ値はInteger.MAX_VALUEです。

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

• FIRST_NONZEROの場合、リダクションは最小番号のゼロ以外のレーンから値を返します。
• その他のリダクション演算はすべて、完全に可換的であり、連想的です。 実装では任意の処理順序を選択できますが、常に同じ結果が生成されます。

パラメータ:

op - レーン値を結合するために使用される演算

m - マスク制御レーンの選択

戻り値:

選択されたレーン値から累積された還元結果

例外:

UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合

関連項目:

• reduceLanes(VectorOperators.Associative)

lane

public abstract int lane(int i)

レーン索引iのレーン要素を取得

パラメータ:

i - レーンのインデックス

戻り値:

レーン索引iのレーン要素

例外:

IllegalArgumentException - 索引が(< 0 || >= length())の範囲外であるかどうか

withLane

public abstract IntVector withLane(int i, int e)

レーン索引iにあるこのベクトルのレーン要素を値eに置き換えます。 これはクロス・レーン演算であり、このベクトルを、eをブロードキャストした結果である入力ベクトルおよびレーン索引iでレーンが1つのみ設定されているマスクとブレンドした結果を返すかのように動作します。

パラメータ:

i - 置換されるレーン要素のレーン索引

e - 配置される値

戻り値:

レーン索引iにあるこのベクトルのレーン要素を値eで置き換えた結果。

例外:

IllegalArgumentException - 索引が(< 0 || >= length())の範囲外であるかどうか

toArray

public final int[] toArray()

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

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

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

定義:

クラスVector<Integer>のtoArray

戻り値:

このベクトルのレーン値を含む配列

関連項目:

• ByteVector.toArray()
• toArray()
• DoubleVector.toArray()

toIntArray

public final int[] toIntArray()

int型に変換された、すべてのレーン値を含むint[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプが floatまたはdoubleの場合、この演算は失敗する可能性があります。 ベクトル・レーン値がintとして表現できない場合は、例外がスローされます。 これはtoArray()の別名です。このメソッドをIntVector型のベクトルで使用すると、範囲や精度は失われません。

定義:

クラスVector<Integer>のtoIntArray

戻り値:

このベクトルのレーン値を含むint[]配列

関連項目:

• Vector.toArray()
• Vector.toLongArray()
• Vector.toDoubleArray()
• toArray()

toLongArray

public final long[] toLongArray()

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

定義:

クラスVector<Integer>のtoLongArray

実装上のノート:

このメソッドをIntVector型のベクトルで使用すると、精度や範囲が失われないため、UnsupportedOperationExceptionはスローされません。

戻り値:

このベクトルのレーン値を含むlong[]配列

関連項目:

• Vector.toArray()
• Vector.toIntArray()
• Vector.toDoubleArray()
• LongVector.toArray()

toDoubleArray

public final double[] toDoubleArray()

double型に変換された、すべてのレーン値を含むdouble[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 ベクトル要素タイプがlongの場合、この演算によって精度が失われる可能性があります。

定義:

クラスVector<Integer>のtoDoubleArray

実装上のノート:

このメソッドをIntVector型のベクトルで使用すると、精度は失われません。

戻り値:

このベクトルのレーン値を含むdouble[]配列。表現可能なdouble値に丸められる可能性がある

関連項目:

• Vector.toArray()
• Vector.toIntArray()
• Vector.toLongArray()
• DoubleVector.toArray()

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset)

オフセットから始まるint[]型の配列からベクトルをロードします。 Nがベクトル・レーン索引であるベクトル・レーンごとに、索引offset + Nの配列要素がレーン索引Nの結果のベクトルに配置されます。

パラメータ:

species - 希望するベクトルの種

a - 配列

offset - 配列へのオフセット

戻り値:

配列からロードされたベクトル

例外:

IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)

オフセットからマスクを使用して、int[]型の配列からベクトルをロードします。 マスクが設定されていないレーンには、デフォルト値のint (zero)が設定されます。 Nがベクトル・レーン索引であるベクトル・レーンごとに、索引Nのマスク・レーンが設定されている場合、索引offset + Nの配列要素はレーン索引Nの結果のベクトルに配置されます。それ以外の場合、デフォルトの要素値はレーン索引Nの結果のベクトルに配置されます。

パラメータ:

species - 希望するベクトルの種

a - 配列

offset - 配列へのオフセット

m - マスク制御レーンの選択

戻り値:

配列からロードされたベクトル

例外:

IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)

「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、int[]タイプの配列から要素で構成される新しいベクトルを収集します。 索引マップは、指定された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 IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)

マスクの制御下にあるint[]型の配列から要素で構成される新しいベクトルを収集し、「索引マップ」から一連のセカンダリ・オフセットに固定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()

fromMemorySegment

public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo)

オフセットから始まる「メモリー・セグメント」からベクトルをメモリー・セグメントにロードします。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

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

 var m = species.maskAll(true);
 return fromMemorySegment(species, ms, offset, bo, m);
 

パラメータ:

species - 希望するベクトルの種

ms - メモリー・セグメント

offset - メモリー・セグメントへのオフセット

bo - 目的のバイト・オーダー

戻り値:

メモリー・セグメントから読み込まれたベクトル

例外:

IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N*4 < 0またはoffset+N*4 >= ms.byteSize()の場合

IllegalStateException - メモリー・セグメント・セッションが有効でない場合、またはセッションを所有しているスレッド以外のスレッドからアクセスが発生した場合。

導入されたバージョン:

19

fromMemorySegment

public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)

オフセットから始まる「メモリー・セグメント」からメモリー・セグメントにベクトルをロードし、マスクを使用します。 マスクが設定されていないレーンには、デフォルト値のint (zero)が設定されます。 バイトは、指定されたバイト順序に従ってプリミティブなレーン要素に構成されます。 ベクトルは、「メモリーの順序」に従ってレーンに配置されます。

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

 var slice = ms.asSlice(offset);
 int[] ar = new int[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT.withByteAlignment(1), n);
     }
 }
 IntVector r = IntVector.fromArray(species, ar, 0);
 

実装上のノート:

このメソッドはレーン値のバイトを並べ替える必要がないため、指定されたバイト順序が「プラットフォームのネイティブ順序」と同じ場合は、この演算がより効率的になる可能性があります。

パラメータ:

species - 希望するベクトルの種

ms - メモリー・セグメント

offset - メモリー・セグメントへのオフセット

bo - 目的のバイト・オーダー

m - マスク制御レーンの選択

戻り値:

メモリー・セグメントから読み込まれたベクトル

例外:

IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N*4 < 0またはoffset+N*4 >= ms.byteSize()の場合

IllegalStateException - メモリー・セグメント・セッションが有効でない場合、またはセッションを所有しているスレッド以外のスレッドからアクセスが発生した場合。

導入されたバージョン:

19

intoArray

public final void intoArray(int[] a, int offset)

このベクトルをオフセットから始まるint[]型の配列に格納します。

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

パラメータ:

a - int[]型の配列

offset - 配列へのオフセット

例外:

IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

intoArray

public final void intoArray(int[] a, int offset, VectorMask<Integer> m)

このベクトルを、オフセットから始めてマスクを使用するint[]型の配列に格納します。

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

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

パラメータ:

a - int[]型の配列

offset - 配列へのオフセット

m - マスク制御レーンのストレージ

例外:

IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N < 0またはoffset+N >= a.lengthの場合

intoArray

public final void intoArray(int[] a, int offset, int[] indexMap, int mapOffset)

「索引マップ」から一連のセカンダリ・オフセットに固定offsetを追加して取得した索引を使用して、このベクトルをint[]型の配列に分散します。 索引マップは、指定された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(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)

このベクトルを、マスクの制御下にあるint[]型の配列に分散し、「索引マップ」から一連のセカンダリ・オフセットに固定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()

intoMemorySegment

public final void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)

このベクトルを、明示的なバイト順序を使用してオフセットから始まる「メモリー・セグメント」に格納します。

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

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

 var m = maskAll(true);
 intoMemorySegment(ms, offset, bo, m);
 

定義:

クラスVector<Integer>のintoMemorySegment

パラメータ:

ms - メモリー・セグメント

offset - メモリー・セグメントへのオフセット

bo - 目的のバイト・オーダー

導入されたバージョン:

19

intoMemorySegment

public final void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)

このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。

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

次の疑似コードは動作を示しています。ここで、JAVA_Eはプリミティブ要素タイプのレイアウト、ETYPEはプリミティブ要素タイプ、EVectorはこのベクトルのプリミティブ・ベクトル・タイプです:

 ETYPE[] a = this.toArray();
 var slice = ms.asSlice(offset)
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         slice.setAtIndex(ValueLayout.JAVA_E.withBitAlignment(8), n);
     }
 }
 

定義:

クラスVector<Integer>のintoMemorySegment

パラメータ:

ms - メモリー・セグメント

offset - メモリー・セグメントへのオフセット

bo - 目的のバイト・オーダー

m - マスク制御レーンの選択

導入されたバージョン:

19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyteでは、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。 これは、式reinterpretShape(species().withLanes(byte.class))の簡易メソッドです。 これは、Vector.reinterpretAsInts()など、同じベクトル内の大きいレーンにバイトを統合する様々なメソッドとは逆であると考えられます。

定義:

クラスVector<Integer>のreinterpretAsBytes

戻り値:

同じシェイプおよび情報コンテンツを持つByteVector

関連項目:

• Vector.reinterpretShape(VectorSpecies,int)
• intoMemorySegment(java.lang.foreign.MemorySegment, long, java.nio.ByteOrder)
• FloatVector.intoMemorySegment(java.lang.foreign.MemorySegment, long, java.nio.ByteOrder)
• VectorSpecies.withLanes(Class)

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

定義:

クラスVector<Integer>のviewAsIntegralLanes

戻り値:

非浮動小数点として再解釈された、元のベクトル

関連項目:

• VectorOperators.Conversion.ofReinterpret(Class,Class)
• Vector.convert(VectorOperators.Conversion,int)

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

定義:

クラスVector<Integer>のviewAsFloatingLanes

戻り値:

浮動小数点として再解釈された、元のベクトル

関連項目:

• VectorOperators.Conversion.ofReinterpret(Class,Class)
• Vector.convert(VectorOperators.Conversion,int)

toString

public final String toString()

このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"形式のこのベクトルの文字列表現を返します。 この文字列は、this.toArray()から返されるint配列に応じて、Arrays.toString()へのコールによって生成されるかのように生成されます。

定義:

クラスVector<Integer>のtoString

戻り値:

このベクトルのレーン値を報告する"[0,1,2...]"形式の文字列

equals

public final boolean equals(Object obj)

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

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

定義:

クラスVector<Integer>のequals

パラメータ:

obj - 比較対象の参照オブジェクト。

戻り値:

このベクトルがほかのオブジェクトと同一かどうか

関連項目:

• Vector.eq(jdk.incubator.vector.Vector<E>)

hashCode

public final int hashCode()

レーン値とベクトル種に基づいて、ベクトルのハッシュ・コード値を返します。

定義:

クラスVector<Integer>のhashCode

戻り値:

このベクトルのハッシュ・コード値

関連項目:

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.Object)

species

public final VectorSpecies<Integer> 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 - 必要な種

戻り値:

同じベクトル

関連項目:

• Vector.check(Class)
• VectorMask.check(VectorSpecies)
• VectorShuffle.check(VectorSpecies)

check

public final <F> Vector<F> check(Class<F> elementType)

このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。 効果は次の疑似コードのようになります : 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<Integer> 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<Integer,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 - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ

戻り値:

このベクトルからシェイプおよび要素型によって変換されたベクトル

関連項目:

• 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<Integer,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)

getPayload

protected final Object getPayload()