- 型パラメータ:
E
-ETYPE
のボックス版、ベクトルの要素型
- 直系の既知のサブクラス:
ByteVector
,DoubleVector
,FloatVector
,IntVector
,LongVector
,ShortVector
byte
、long
、float
などの一部の固定「要素型」である、固定数の「レーン」の順序。 各レーンには、要素タイプの独立した値が含まれます。 ベクトルに対する演算は通常レーンワイズであり、一部のスカラー演算子(「加算」など)が参加ベクトルのレーンに分散され、通常、レーンに様々なスカラー結果が含まれるベクトル結果が生成されます。 サポートしているプラットフォームで実行すると、ハードウェアでレーンワイズ演算をパラレルに実行できます。 この並列度スタイルは、「単一指図複数データ」 (SIMD)並列度と呼ばれます。
SIMD形式のプログラミングでは、ベクトル・レーン内のほとんどの演算は無条件ですが、関連付けられたVectorMask
の制御下で、blend()
などの「マスクされた演算」を使用して条件付き実行の効果を得ることができます。 厳密にレーンワイズ・フロー以外のデータ移動は、多くの場合、関連するVectorShuffle
の制御下で、クロスレーン演算を使用して実現されます。 レーン・データまたはベクトル全体(あるいはその両方)は、様々な種類のレーンワイズ「変換」またはバイト単位の再フォーマットreinterpretationsを使用して再フォーマットでき、多くの場合、入力ベクトルとは異なる代替ベクトル・フォーマットを選択する反射VectorSpecies
オブジェクトの制御下で再フォーマットされます。
Vector<E>
では、すべての要素タイプに共通のベクトル演算(メソッド)のセットを宣言します。 これらの一般的な演算には、レーン値への汎用アクセス、データの選択と移動、再フォーマット、およびすべてのプリミティブ型に共通する特定の算術演算子と論理演算子の(加算や比較など)が含まれます。
「Vector
のパブリック・サブタイプ」は、特定の要素タイプに対応します。 これらは、レーン値へのボックス化されていないアクセス、整数要素型の値に対するビット単位の演算、浮動小数点要素型の値に対するトランザクション演算など、その要素型に固有のさらなる演算を宣言します。
add
演算子などの一部のレーンワイズ演算は、フル・サービス名前付き演算として定義されます。この場合、Vector
の対応するメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードになり、(サブクラス)は(サブクラスを返す)および追加のスカラー・ブロードキャスト・オーバーロード(マスク済とマスク解除済の両方)もオーバーライドします。 min
演算子などのその他のレーンワイズの演算は、部分的にサービスされる(フル・サービスではありません)名前付き演算として定義されます。ここでは、Vector
またはサブクラス(あるいはその両方)の対応するメソッドによって、可能性のあるすべてのオーバーロードが提供され、(一般的に、スカラー・ブロードキャスト・オーバーロードのあるマスクされていない可変)がオーバーライドされます。 最後に、レーンワイズすべての演算の(前述のように指定されたもの、または名前のないメソッドに関するもの)には、対応するoperator token
がVectorOperators
で静的定数として宣言されています。 各演算子トークンは、ADD
演算子トークン用のa + b
など、演算のシンボリックJava式を定義します。 「単項レーンワイズ」演算などの一般的なレーンワイズ演算トークン受入れメソッドは、Vector
で提供され、フル・サービス名前付き演算と同じバリアントになります。
このパッケージには、サポートされている各要素タイプに対応するVector
のパブリック・サブタイプが含まれます: ByteVector
、ShortVector
、IntVector
、LongVector
、FloatVector
およびDoubleVector
。
ETYPE
と呼ばれるベクトルの「要素型」は、プリミティブ型byte
, short
, int
, long
, float
またはdouble
のいずれかです。
Vector<E>
のE
タイプは、ETYPE
のboxedバージョンです。 たとえば、タイプがVector<Integer>
の場合、E
パラメータはInteger
で、ETYPE
はint
です。 このようなベクトルでは、各レーンにプリミティブint
値が含まれます。 このパターンは、他のプリミティブ型にも適用されます。 (「Java言語仕様」の5.1.7および5.1.8の項も参照してください。)
ベクトルのlengthはレーン数で、そこに含まれるレーンの数です。 この数値は、コンテキストが属するベクトルを明確にするときにVLENGTH
とも呼ばれます。 各ベクトルには独自の固定VLENGTH
がありますが、ベクトルのインスタンスごとに長さが異なる場合があります。 VLENGTH
は、ベクトル演算の基礎となるVLENGTH
スカラー演算子のスカラー実行と比較して、単一のベクトル演算のSIMDパフォーマンス向上を見積もるため、重要な数値です。
Shapesとspecies
ベクトルの情報容量は、ベクトルのVSHAPE
とも呼ばれる「ベクトル・シェイプ」によって決定されます。 可能な各VSHAPE
は、VectorShape
列挙のメンバーによって表され、そのシェイプのすべてのベクトルで共通に共有される実装形式を表します。 したがって、ベクトルの「ビット単位のサイズ」は、ベクトルのシェイプに応じて決定されます。
一部のJavaプラットフォームでは、単一のシェイプにのみ特別なサポートが提供されますが、その他のプラットフォームでは複数のシェイプがサポートされます。 一般的なプラットフォームでは、このAPIで記述されているすべてのシェイプがサポートされているとはかぎりません。 このため、ほとんどのベクトル演算は単一の入力シェイプで機能し、出力時に同じシェイプを生成します。 シェイプを変更する演算は、そのようなshape-changingとして明確に文書化されていますが、ほとんどの演算はシェイプ不変です。これにより、単一シェイプのみをサポートする不利なプラットフォームを回避できます。 現在のJavaプラットフォームには、一般的なSIMD計算用の「優先シェイプ」、または特定のレーン・タイプで使用可能な最大のシェイプを検出する問合せがあります。 移植性を確保するために、このAPIを使用するコードは、サポートされているシェイプを問い合せてから、選択したシェイプ内のシェイプ不変演算ですべてのデータを処理する必要があります。
要素タイプとベクトル・シェイプの一意の組合せによって、一意の「ベクトル種」が決まります。 ベクトル種は、同じシェイプのすべてのベクトルとETYPE
で共有されるVectorSpecies<E>
の固定インスタンスによって表されます。
特に明記されていないかぎり、レーンワイズ・ベクトル演算では、すべてのベクトル入力がまったく同じVSHAPE
およびVLENGTH
を持つ必要があります。つまり、これらの入力はまったく同じ種である必要があります。 これにより、対応するレーンを明確にペアにすることができます。 check()
メソッドは、このチェックを明示的に実行する簡単な方法を提供します。
ベクトル・シェイプ、VLENGTH
およびETYPE
はすべて相互に制約されるため、「各レーンのビット・サイズ」のVLENGTH
時間はベクトル・シェイプのビット・サイズと常に一致する必要があります。 したがって、ベクトルの「再解釈」の長さは、レーン・サイズの半分であるか、シェイプを変更した場合にのみ倍増することがあります。 同様に、ベクトルを再解釈すると、長さが半分になるか、ベクトルのシェイプが変更された場合にのみ、レーン・サイズが倍増する可能性があります。
Vectorサブタイプ
Vectorは、すべての要素タイプ(加算など)に共通のベクトル演算(メソッド)のセットを宣言します。 具象要素型を持つVectorのサブクラスは、その要素型(レーン内の要素値へのアクセス、整数要素型の値に対する論理演算、浮動小数点要素型の値に対する置換演算など)に固有の追加演算を宣言します。 Vectorには、サポートされている要素タイプのセット(ByteVector
、ShortVector
、IntVector
、LongVector
、FloatVector
およびDoubleVector
)に対応する6つの抽象サブクラスがあります。 これらのクラスは、型固有の演算とともに、ベクトル値(Vectorのインスタンス)の作成をサポートします。 サポートされている種に対応するstatic定数を公開し、これらの型のstaticメソッドは通常、パラメータとして種を取ります。 たとえば、FloatVector.fromArray
は、指定されたfloat配列からロードされた要素を使用して、指定された種のfloatベクトルを作成して返します。 実行時コンパイラによってVector値が最適に作成および使用されるように、Speciesインスタンスをstatic final
フィールドに保持することをお薦めします。
型指定ベクトル・クラスによって定義される静的定数の例として、定数FloatVector.SPECIES_256
はレーンがfloat
であり、ベクトル・サイズが256ビットである一意の種です。 ここでも、定数FloatVector.SPECIES_PREFERRED
は、現在実行中のJavaプラットフォームでfloat
ベクトル・レーンの処理を最適にサポートする種です。
別の例として、DoubleVector.broadcast(dsp, 0.5)
を呼び出すことで(double)0.5
のブロードキャスト・スカラー値を取得できますが、結果のベクトルの種(したがって、シェイプと長さ)を選択するには、引数dsp
が必要です。
レーンワイズ演算
ベクトルに対する演算を定義する場合は、「レーン」という用語を使用します。 ベクトル内のレーンの数は、保持するスカラー要素の数です。 たとえば、float
およびシェイプS_256_BIT
型のベクトルには、32*8=256
以降8つのレーンがあります。
ベクトルに対するほとんどの演算はレーンワイズです。つまり、演算は基礎となるスカラー演算子で構成され、入力ベクトルの個別のレーンごとに繰り返されます。 同じ型の追加のベクトル引数がある場合、それらのレーンは最初の入力ベクトルのレーンに整列されます。 (これらはすべて共通のVLENGTH
を持っている必要があります。) レーンワイズ演算の結果の出力には、演算への入力のVLENGTH
と等しいVLENGTH
が含まれます。 したがって、レーンワイズ演算は、その基本的な定義では長さ不変です。
長さ不変の原則は別の基本原則と組み合されており、レーンワイズ演算は常にシェイプ不変です。つまり、レーンワイズ演算の入力と出力には共通のVSHAPE
があります。 論理結果(不変のVLENGTH
を使用)が不変のVSHAPE
に収まらないために原則が競合する場合、結果の拡張および縮小は「特殊な表記規則」で明示的に処理されます。
ベクトル演算は様々なカテゴリにグループ化でき、その動作は通常、基礎となるスカラー演算子によって指定できます。 次の例では、ETYPE
は演算(int.class
など)の要素タイプで、EVector
は対応する具体的なベクトル・タイプ(IntVector.class
など)です。
-
w = v0.
neg
()
などの「レーンワイズ単項」演算は、単項スカラー演算子をレーン全体に分散して入力ベクトルを取り、同じタイプおよびシェイプの結果ベクトルを生成します。 入力ベクトルa
のレーンごとに、基礎となるスカラー演算子がレーン値に適用されます。 結果は、同じレーンのベクトル結果に配置されます。 次の疑似コードは、この演算カテゴリの動作を示しています:ETYPE scalar_unary_op(ETYPE s); EVector a = ...; VectorSpecies<E> species = a.species(); ETYPE[] ar = new ETYPE[a.length()]; for (int i = 0; i < ar.length; i++) { ar[i] = scalar_unary_op(a.lane(i)); } EVector r = EVector.fromArray(species, ar, 0);
-
w = v0.
add
(v1)
などの「レーンワイズ二項」演算は、二項スカラー演算子をレーン全体に分散して2つの入力ベクトルを取り、同じタイプおよびシェイプの結果ベクトルを生成します。a
とb
の両方の入力ベクトルのレーンごとに、基礎となるスカラー演算子がレーン値に適用されます。 結果は、同じレーンのベクトル結果に配置されます。 次の疑似コードは、この演算カテゴリの動作を示しています:ETYPE scalar_binary_op(ETYPE s, ETYPE t); EVector a = ...; VectorSpecies<E> species = a.species(); EVector b = ...; b.check(species); // must have same species ETYPE[] ar = new ETYPE[a.length()]; for (int i = 0; i < ar.length; i++) { ar[i] = scalar_binary_op(a.lane(i), b.lane(i)); } EVector r = EVector.fromArray(species, ar, 0);
-
単項演算および二項演算からの一般化では、レーンワイズn項演算は
N
入力ベクトルv[j]
を使用して、n項スカラー演算子をレーン全体に分散し、同じ型およびシェイプの結果ベクトルを生成します。w = v0.
fma
(v1,v2)
などのいくつかの三項演算を除き、このAPIではレーンワイズn項演算はサポートされていません。 すべての入力ベクトルv[j]
のレーンごとに、基礎となるスカラー演算子がレーン値に適用されます。 結果は、同じレーンのベクトル結果に配置されます。 次の疑似コードは、この演算カテゴリの動作を示しています:ETYPE scalar_nary_op(ETYPE... args); EVector[] v = ...; int N = v.length; VectorSpecies<E> species = v[0].species(); for (EVector arg : v) { arg.check(species); // all must have same species } ETYPE[] ar = new ETYPE[a.length()]; for (int i = 0; i < ar.length; i++) { ETYPE[] args = new ETYPE[N]; for (int j = 0; j < N; j++) { args[j] = v[j].lane(i); } ar[i] = scalar_nary_op(args); } EVector r = EVector.fromArray(species, ar, 0);
-
w0 = v0.
convert
(VectorOperators.I2D, 0)
などの「レーンワイズ変換」演算は、単項スカラー変換演算子をレーン全体に分散して入力ベクトルを取り、変換された値の論理結果を生成します。 論理結果(または少なくともその一部)は、入力ベクトルと同じシェイプのベクトルで表されます。他のレーンワイズ演算とは異なり、変換では、レーン・タイプを入力(domain)タイプから出力(範囲)タイプに変更できます。 レーンのサイズは、タイプに応じて変わる場合があります。 サイズ変更を管理するために、レーンワイズ変換メソッドでは、「他の場所で説明されている」
part
パラメータの管理下で「部分的な結果」を製品化できます。 (前述の例に従うと、変換されたレーン値の別のグループをw1 = v0.convert(VectorOperators.I2D, 1)
として取得できます。)次の疑似コードは、
int
からdouble
への変換の特定の例におけるこの演算カテゴリの動作を示しており、シェイプの不変性を維持するために下位または上位レーンの(part
に依存)が保持されています:IntVector a = ...; int VLENGTH = a.length(); int part = ...; // 0 or 1 VectorShape VSHAPE = a.shape(); double[] arlogical = new double[VLENGTH]; for (int i = 0; i < limit; i++) { int e = a.lane(i); arlogical[i] = (double) e; } VectorSpecies<Double> rs = VSHAPE.withLanes(double.class); int M = Double.BITS / Integer.BITS; // expansion factor int offset = part * (VLENGTH / M); DoubleVector r = DoubleVector.fromArray(rs, arlogical, offset); assert r.length() == VLENGTH / M;
-
e = v0.
reduceLanes
(VectorOperators.ADD)
などの「レーンを越える削減」演算は、入力ベクトルのすべてのレーン要素で動作します。 累積関数は、スカラー結果を生成するためにすべてのレーン要素に適用されます。 リダクション演算が連想的な場合、結果は、指定された連想スカラー二項演算およびアイデンティティ値を使用して、任意の順序でレーン要素を演算することで累積できます。 それ以外の場合は、リダクション演算によって累積の順序が指定されます。 次の疑似コードは、この演算カテゴリが連想型の場合の動作を示しています:ETYPE assoc_scalar_binary_op(ETYPE s, ETYPE t); EVector a = ...; ETYPE r = <identity value>; for (int i = 0; i < a.length(); i++) { r = assoc_scalar_binary_op(r, a.lane(i)); }
-
w = v0.
rearrange
(shuffle)
などの「レーンを越える移動」演算は、入力ベクトルのすべてのレーン要素に対して動作し、データ依存の方法で出力ベクトルの「異なるレーン」に移動します。 移動は、VectorShuffle
や、移動の起点を定義するスカラー索引などの補助データムによって制御されます。 次の擬似コードは、シャッフルの場合のこの演算カテゴリの動作を示しています:EVector a = ...; Shuffle<E> s = ...; ETYPE[] ar = new ETYPE[a.length()]; for (int i = 0; i < ar.length; i++) { int source = s.laneSource(i); ar[i] = a.lane(source); } EVector r = EVector.fromArray(a.species(), ar, 0);
-
「マスクされた演算」は、前のいずれかの演算(レーンワイズまたはクロス・レーン)のバリエーションであり、この演算は余分な末尾の
VectorMask
引数を取ります。 レーンではマスクが設定されていますが、マスク引数がないかのように動作しますが、マスクが設定解除されているレーンでは、基礎となるスカラー演算は抑制されます。 マスクされた演算は、「他の場所の詳細」で説明されています。 -
マスクされたレーンワイズ二項演算の非常に特殊なケースは、「ブレンド」です。これは、マスク
m
に応じて一方の入力からレーン値を選択して、2つの入力ベクトルa
およびb
でレーンワイズ演算を行います。m
が設定されているレーンでは、b
の対応する値が結果に選択されます。それ以外の場合は、a
の値が選択されます。 したがって、ブレンドは、ベクトル化されたバージョンのJava三項選択式m?b:a
として機能します :ETYPE[] ar = new ETYPE[a.length()]; for (int i = 0; i < ar.length; i++) { boolean isSet = m.laneIsSet(i); ar[i] = isSet ? b.lane(i) : a.lane(i); } EVector r = EVector.fromArray(species, ar, 0);
-
m = v0.
lt
(v1)
などの「レーンワイズ二項テスト」演算は、二項スカラー比較をレーン全体に分散し、ブールのベクトルではなく「ベクトル・マスク」を生成する、2つの入力ベクトルを取ります。a
とb
の両方の入力ベクトルのレーンごとに、基礎となるスカラー比較演算子がレーン値に適用されます。 結果として得られるbooleanは、同じレーンのベクトル・マスク結果に配置されます。 次の疑似コードは、この演算カテゴリの動作を示しています:boolean scalar_binary_test_op(ETYPE s, ETYPE t); EVector a = ...; VectorSpecies<E> species = a.species(); EVector b = ...; b.check(species); // must have same species boolean[] mr = new boolean[a.length()]; for (int i = 0; i < mr.length; i++) { mr[i] = scalar_binary_test_op(a.lane(i), b.lane(i)); } VectorMask<E> m = VectorMask.fromArray(species, mr, 0);
-
二項比較と同様に、
m = v0.
test
(IS_FINITE)
などの「レーンワイズ単項テスト」演算は、スカラー述語(a test function)をレーン全体に分散して入力ベクトルを取り、「ベクトル・マスク」を生成します。
ベクトル演算が前述のカテゴリのいずれにも属さない場合、メソッドのドキュメントでは、入力ベクトルのレーンの処理方法を明示的に指定し、必要に応じて擬似コードを使用した動作を示します。
ほとんどのレーンワイズ二項および比較演算では、ベクトルのかわりにスカラーを2番目の入力として受け入れる便利なオーバーロードが提供されます。 この場合、スカラー値は「ブロードキャスト」によってベクトルにプロモートされ、最初の入力と同じレーン構造になります。 たとえば、double
ベクトルのすべてのレーンをスカラー値1.1
で乗算する場合、式v.mul(1.1)
は、v.mul(v.broadcast(1.1))
やv.mul(DoubleVector.broadcast(v.species(), 1.1))
などの明示的なブロードキャスト演算と同等の式よりも簡単に演算できます。 特に指定がないかぎり、スカラー・バリアントは常に、適切なbroadcast
演算を使用して、各スカラー値が最初のベクトル入力と同じ種のベクトルに最初に変換されるかのように動作します。
マスクされた演算
多くのベクトル演算では、オプションのmask
引数を受け入れ、基礎となるスカラー演算子に含めるレーンを選択します。 存在する場合、mask引数はメソッド引数リストの最後に表示されます。
mask引数の各レーンは、setまたはunset状態のブールです。 mask引数が設定されていないレーンの場合、ベースとなるスカラー演算子は抑制されます。 この方法では、マスク・レーンが設定されていない場合を除き、ベクトル演算でSIMD並列性を失わずにスカラー制御フロー演算をエミュレートできます。
マスクによって抑止された演算は、基礎となるスカラー演算子で可能性がある場合でも、ソートの例外または副作用を引き起こすことはありません。 たとえば、範囲外の配列要素にアクセスしたり、整数値をゼロで除算したりするように見える未設定のレーンは無視されます。 抑制されたレーンの値は、演算全体の結果に参加または表示されることはありません。
抑制された演算に対応する結果レーンには、次のように、特定の演算に依存するデフォルト値が入力されます:
- マスクされた演算が単項演算、二項演算、n項演算または論理演算の場合、抑制されたレーンは、「ブレンド」による場合と同様に最初のベクトル・オペランド(つまり、メソッド・コールを受信するベクトル)から入力されます。
- マスクされた演算が別のベクトルからのメモリー負荷または
slice()
である場合、抑制されたレーンはロードされず、すべてゼロ・ビットで構成されるETYPE
のデフォルト値が入力されます。 未設定のレーンは、仮想的に対応するメモリーのロケーションが(配列索引範囲外であるため)に存在しない場合でも、例外を引き起こすことはありません。 - 演算が、レーン索引を提供するオペランドを持つクロス・レーン演算である場合(
VectorShuffle
またはVector
タイプ)、抑制されたレーンは計算されず、ゼロのデフォルト値が入力されます。 通常、無効なレーン索引はIndexOutOfBoundsException
を要求しますが、レーンが設定されていない場合は、索引に関係なくゼロ値が静止して置換されます。 このルールは、マスクされたメモリー・ロードの前述のルールに似ています。 - マスクされた演算がメモリー・ストアまたは別のベクトルへの
unslice()
である場合、抑制されたレーンは格納されず、対応するメモリーまたはベクトルのロケーションの(もしあれば)は変更されません。(Note: 抑制されたレーンでは、競合状態などのメモリー効果は発生しません。 つまり、実装では、未設定のレーンの既存の値は機密的に書き換えられません。 Javaメモリー・モデルでは、メモリー変数を現在の値に再割当てしても操作は行われません。別のスレッドから競合するストアが静止して元に戻される可能性があります。)
- マスクされた演算がリダクションの場合、抑制されたレーンはリダクションで無視されます。 すべてのレーンが抑制されると、特定のリダクション演算に応じて適切なニュートラル値が返され、そのメソッドのマスクされたバリアントによってドキュメント化されます。 (つまり、ユーザーは、オール・アン・セット・マスクを使用してダミー・ベクトルのリダクションを実行することで、プログラムでニュートラル値を取得できます。)
- マスクされた演算が比較演算の場合、抑制された入力値に関係なく、抑制された比較演算が
false
を返したかのように、結果のマスクの抑制された出力レーン自体が設定解除されます。 実際には、比較演算がマスクされずに実行された後、結果が制御マスクと交差していました。 - マスキングされた「レーン横断運動」などのその他の場合、マスキングの特定の効果はメソッドのマスク・バリアントによってドキュメント化されます。
たとえば、2つの入力ベクトルa
およびb
でのマスクされた二項演算では、マスクが設定解除されているレーンの二項演算が抑制され、a
からの元のレーン値が保持されます。 次の疑似コードは、この動作を示しています:
ETYPE scalar_binary_op(ETYPE s, ETYPE t);
EVector a = ...;
VectorSpecies<E> species = a.species();
EVector b = ...;
b.check(species); // must have same species
VectorMask<E> m = ...;
m.check(species); // must have same species
boolean[] ar = new boolean[a.length()];
for (int i = 0; i < ar.length; i++) {
if (m.laneIsSet(i)) {
ar[i] = scalar_binary_op(a.lane(i), b.lane(i));
} else {
ar[i] = a.lane(i); // from first input
}
}
EVector r = EVector.fromArray(species, ar, 0);
レーン順序およびバイト順序
特定のベクトルに格納されるレーン値の数は、その「ベクトル長さ」またはVLENGTH
と呼ばれます。 ベクトル・レーンは、0
という番号の最初のレーン、1
という番号の次のレーン、VLENGTH-1
という番号の最後のレーンなどで、最初から最後まで「順次」を順序付けたものとみなすと便利です。 これは一時的な順序であり、下位番号のレーンは上位番号の(後で)レーンより前とみなされます。 このAPIは、"left"、"right"、"high"、"low"などの空間用語よりもこれらの用語を優先して使用します。
時間的な用語は、ベクトルに対して適切に機能します。これは、(通常は)がワークロード要素の長いシーケンスで小さい固定サイズのセグメントを表し、ワークロードが概念的に時間順にトラバースされるためです。 (これはmentalモデルです: マルチ・コアの分割統治技術は除外されません。) したがって、スカラー・ループがベクトル・ループに変換されると、ワークロード内の隣接スカラー・アイテム(1つ前、もう1つ後)は単一のベクトル(1つ前、もう1つ後)内の隣接レーンとして終了します。 ベクトル境界では、前のベクトルの最後のレーン・アイテムは、直後のベクトルの最初のレーン・アイテムである(および直前)に隣接します。
ベクトルは空間用語でも考慮されることがあります。空間用語では、最初のレーンは仮想用紙の端に配置され、後続のレーンはその横に順番に表示されます。 空間的な用語を使用する場合、すべての方向は同等に配置できます: ベクトル表記法の中には、左から右にレーンを表示するものもあれば、右から左にレーンを表示するものもあれば、上から下にレーンを表示するものもあります。 スペース(left、right、high、low)のかわりに(before、after、first、last)の時間の言語を使用すると、誤解を避ける可能性が高くなります。
ベクトル・レーンに関して空間言語より時間的に優先するもう1つの理由は、"left"、"right"、"high"および"low"という用語がスカラー値のビット間の関係を説明するために広く使用されていることです。 指定された型の左端または最上位のビットは符号ビットである可能性が高く、右端または最下位のビットは算術的に最下位ビットである可能性が高くなります。 ただし、ベクトル・レーンにこれらの用語を適用すると、2つの隣接するベクトル・レーンがバーよりも演算的に重要なアルゴリズムを見つけることは比較的まれであるため、このような場合でも、どのバーが重要であるかを知る一般的な方法はありません。
用語をまとめると、ベクトルの情報構造は、内部的に空間的に("low"から"high"または"right"から"left"のいずれか)で順序付けされたビット文字列のレーン("first", "next", "前", "後で", "last", etc.)の一時的なシーケンスとして表示されます。 レーンのプリミティブ値は、通常の方法でこれらのビット文字列からデコードされます。 ほとんどのベクトル演算子は、ほとんどのJavaスカラー演算子と同様に、プリミティブ値をアトミック値として扱いますが、一部の演算子では内部ビット文字列構造が明らかになります。
ベクトルがメモリーからロードされるか、メモリーに格納される場合、ベクトル・レーンの順序は、メモリー・コンテナの固有の順序を持つ「常に一貫性がある」です。 これは、バイト・オーダーの詳細のために個々のレーン要素が"バイト・スワップ"の対象であるかどうかにかかわらず当てはまります。 したがって、ベクトルのスカラー・レーン要素は"スワップされたバイト"である可能性がありますが、レーンの順序変更を実行する明示的なメソッド・コールを除き、レーン自体は順序変更されません。
ベクトル・レーン値が同じタイプのJava変数に格納されている場合、ベクトル・ハードウェアの実装でこのようなスワッピングが必要な場合にのみバイト・スワッピングが実行されます。 したがって、無条件で不可視です。
このAPIは、有用なフィクションとして、ベクトル・レーンのバイトが「リトル・エンディアン順序」の大きいレーンのスカラーに構成されているという一貫した状況を表します。 つまり、ベクトルをJavaバイト配列に格納すると、ネイティブ・メモリーの順序や、ベクトル・ユニット・レジスタ内のバイト順序(もしあれば)に関係なく、すべてのプラットフォームでベクトル・レーン値の連続バイトがリトル・エンディアン順で表示されます。
この仮想リトル・エンディアン順序は、ベクトル・ビットを変更せずにレーン境界が破棄および再描画されるような方法で「再解釈キャスト」を適用した場合にも表示されます。 このような演算では、隣接する2つのレーンが単一の新しいレーン(またはその逆)にバイトを提供し、2つのレーンの順序によって単一レーン内のバイトの算術順序が決定されます。 この場合、リトル・エンディアン規則によって移植可能な結果が提供されるため、すべてのプラットフォームで、以前のレーンでは下位(右方向)ビットがコントリビュートされ、後続のレーンでは上位(左向き)ビットがコントリビュートされる傾向があります。 ByteVector
とその他の非バイト・ベクトル間の「再解釈キャスト」では、移植可能なセマンティクスを明確にするためにこの規則が使用されます。
レーンの順序をレーンごとのバイト順序に関連付けるリトル・エンディアンのフィクションは、同等のビッグ・エンディアンのフィクションよりも若干推奨されます。これは、一部の関連する式(特にレーン構造の変更後にバイト数を再番号付けする式)がはるかに単純であるためです。 もっとも古いバイトは、リトル・エンディアン規則が使用されている場合にかぎり、レーン構造のすべての変更において不変的に早いバイトです。 この根本的な原因は、スカラー内のバイトに、最も重要度の低い(右端)から最も重要度の高い(左端)までの番号が付けられ、その逆も同様ではないことです。 符号ビットの番号がゼロ(一部のコンピュータと同様)である場合、このAPIはビッグ・エンディアンのフィクションに到達し、ベクトル・バイトの統一アドレスを作成します。
メモリー操作
前述のように、ベクトルはメモリーからロードして戻すことができます。 オプションのマスクを使用すると、読み取りまたは書き込みの対象となる個々のメモリー・ロケーションを制御できます。 ベクトルのシェイプによって、ベクトルが占有するメモリー量が決まります。 実装には通常、マスキングがない場合、レーンはスカラー型の配列内の単一スカラー値の稠密な(gap-free)系列と同じように、バック・トゥ・バック値の稠密なシーケンスとしてメモリーに格納されるというプロパティがあります。 このような場合、メモリーの順序はレーンの順序に正確に対応します。 最初のベクトル・レーン値は、メモリー内の最初の位置を占有し、ベクトルの長さまで続きます。 さらに、ストアド・ベクトル・レーンのメモリー順序は、Java配列またはByteBuffer
での索引値の増加に対応しています。
ストレージされたベクトル値を、ベクトルを保持する配列またはバッファ内で単一のプリミティブ値として読み取ったり書き込んだりできるように、レーン・ストレージのバイト順が選択され、ベクトル内のレーンワイズ値と同じ値が生成されます。 このことは、ベクトルの内側のレーンの値がリトル・エンディアン順に格納されるという便利なフィクションとは無関係です。
たとえば、FloatVector.fromArray(fsp,fa,i)
は、float配列fa
からロードされた要素を使用して、特定の種のfsp
のfloatベクトルを作成して返します。 最初のレーンはfa[i]
からロードされ、最後のレーンはfa[i+VL-1]
からロードされます。VL
は、種fsp
から導出されたベクトルの長さです。 次に、fv=fv.add(fv2)
は、同じ種のfsp
のベクトルfv2
を使用して、その種のfsp
の別のfloatベクトルを生成します。 次に、mnz=fv.compare(NE, 0.0f)
は結果がゼロかどうかをテストし、マスクmnz
を生成します。 ゼロ以外のレーンの(これらのレーンのみ)は、文fv.intoArray(fa,i,mnz)
を使用して元の配列要素に格納できます。
拡張、縮小および結果の一部
ベクトルはサイズが固定されているため、多くの場合、演算の論理結果が提案された出力ベクトルの物理サイズと異なる場合があります。 移植性が高く、可能なかぎり予測可能なユーザー・コードを推薦するために、このAPIには、このような「サイズ変更」ベクトル演算の設計に対する体系的なアプローチがあります。 基本原則として、レーンワイズ演算は長さ不変です。 長さ不変とは、VLENGTH
レーンが演算に入ると、同じ数のレーンが破棄されず、余分なパディングも行われないことを意味します。
別の原則として、特に明らかにマークされていないかぎり、最初のレーンワイズ演算の時制がシェイプ不変でもある場合があります。 シェイプ不変性とは、VSHAPE
が一般的な計算に対して一定であることを意味します。 計算全体で同じシェイプを維持することで、十分なベクトル・リソースが効率的に使用されるようになります。 (一部のハードウェア・プラットフォームでは、シェイプを変更すると、余分なデータ移動指示、メモリー内のラウンドトリップ、パイプライン・バブルなどの不要な影響が発生する可能性があります。)
これらの原則間の張力は、演算によって生成される「論理結果」が、必要な出力VSHAPE
に対して大きすぎる場合に発生します。 また、論理結果が出力VSHAPE
の容量より小さい場合、物理出力ベクトルには論理結果とパディングが混在している必要があるため、論理結果の位置は問題になります。
最初のケースでは、大きすぎる論理結果が小さすぎる出力VSHAPE
に詰め込まれる場合、データは「拡張した」と言います。 つまり、「拡張演算」が原因で出力シェイプがオーバーフローしています。 大きな出力VSHAPE
に適合する小さな論理結果の2番目のケースでは、データは縮小があり、「縮小演算」は出力シェイプに余分なゼロ・レーンを埋め込む必要があります。
どちらの場合も、論理結果サイズ(ビット単位)と実際の出力シェイプのビット・サイズの間で「拡張率」または「縮小率」を測定するパラメータM
を使用できます。 ベクトル・シェイプが変更され、レーンのサイズが変更されていない場合、M
は論理結果に対する出力シェイプの積分的な比率にすぎません。 (「最大シェイプ」を除き、ベクトル・サイズはすべて2の累乗であるため、比率M
は常に整数です。 整数以外の比率の場合、値M
は次の整数に切り上げられ、同じ一般的な考慮事項が適用されます。)
論理結果が物理出力シェイプより大きい場合、このようなシェイプの変更は結果レーン(論理結果の1/M
以外のすべて)を必然的に削除する必要があります。 論理サイズが出力より小さい場合、シェイプを変更すると、パディング(物理出力の1/M
以外のすべて)のゼロ埋めレーンが導入されます。 レーンがドロップされた最初のケースは拡張で、2番目のケースにパディング・レーンが追加されたケースは縮小です。
同様に、シェイプを不変のままにし、レーンのサイズをM
の比率で変更するレーンワイズの変換演算について考えてみます。 論理結果が出力(または入力)より大きい場合、この変換では出力のVLENGTH
レーンをM
だけ減らし、論理結果レーンの1/M
を除くすべてを削除する必要があります。 以前と同様に、レーンのドロップは拡張部分のハルマルクです。 レーンのサイズをM
の比率で縮小するレーンワイズ演算では、余白を加算する必要があるため、余分なレーンにゼロの埋込み値を入力して、VLENGTH
を同じファクタM
で増やす必要があります。
レーン変換およびシェイプ変更の両方を実行する一方の演算で、レーン・サイズとコンテナ・サイズの両方を変更することもできます(ややわかりにくい)。 これを行うと、同じルールが適用されますが、論理結果サイズは、入力サイズにレーン変更サイズからの拡張または縮小率を掛けた積になります。
完全性のために、サイズ変更が行われない場合の頻度が高いケースについて「インプレース演算」を話すこともできます。 インプレース演算では、データは切り捨てやパディングなしで論理出力から物理コンテナに単純にコピーされます。 この場合、比率パラメータM
はunityです。
縮小と拡張の分類は、論理結果の相対サイズおよび物理出力コンテナによって異なります。 入力コンテナのサイズは、分類を変更せずに、他の2つの値のいずれかより大きくすることも小さくすることもできます。 たとえば、128ビットのシェイプから256ビットのシェイプへの変換は多くの場合縮小になりますが、byte
からlong
への変換と組み合せると、論理結果のサイズが1024ビットになるため、拡張になります。 また、この例は、論理結果が特定のプラットフォームでサポートされているベクトル・シェイプに対応している必要がないことも示しています。
レーンワイズ・マスキングされた演算は、部分演算の生成とみなすことができますが、(このAPI内)は拡張または縮小として分類されません。 配列からのマスクされたロードでは、部分ベクトルが確実に生成されますが、この部分結果が縮小された意味のある"論理出力ベクトル"はありません。
これらの用語は、出力コンテナのサイズに関連して拡張または縮小する「コンテナ・サイズ」ではなく、dataであるため、注意が必要です。 したがって、128ビットの入力を512ビットのベクトルにサイズ変更すると、縮小に影響します。 128ビットのペイロードのサイズは変更されていませんが、新しい512ビット・ホームで"より小さく見える"と言うことができ、これにより状況の実際の詳細が取得されます。
ベクトル・メソッドがそのデータを拡張する可能性がある場合は、part
と呼ばれる追加のint
パラメータまたは"パーツ番号"を受け入れます。 部品番号は[0..M-1]
の範囲内である必要があります。ここで、M
は拡張率です。 部品番号は、論理結果からいずれかのM
連続する不連続レーンのサイズのブロックを選択し、物理出力ベクトルをこのレーンのブロックで埋めます。
具体的には、拡張の論理結果から選択されたレーンには、[R..R+L-1]
の範囲内の番号が付けられます。ここで、L
は物理出力ベクトルのVLENGTH
で、ブロックの起点R
はpart*L
です。
同様の縮小が、そのデータを縮小する可能性のあるベクトル・メソッドにも適用されます。 このようなメソッドでは、追加の部品番号パラメータ(part
を再度呼び出しました)も受け入れられます。このパラメータは、物理出力ベクトル内のレーンのM
隣接するディスジョイントの同サイズのブロックのいずれかを縮小データ・レーンをステアします。 残りのレーンはゼロで埋めるか、メソッドで指定されたとおりに埋められます。
具体的には、[R..R+L-1]
の範囲で番号付けされたレーンにデータが入力されます。ここで、L
は論理結果ベクトルのVLENGTH
であり、ブロックの原点R
は、部品番号で選択されたL
の倍数(具体的には|part|*L
)です。
縮小の場合、部品番号は正でない範囲の[-M+1..0]
内にある必要があります。 この規則が採用されているのは、一部のメソッドではデータ依存のメソッドで拡張と縮小の両方を実行でき、部品番号の余分な符号がエラー・チェックとして機能するためです。 ベクトル・メソッドが部品番号を取り、インプレース演算の(縮小と拡大のいずれでもない)を実行するために呼び出される場合、part
パラメータは正確にゼロである必要があります。 許可された範囲外の部品番号は、索引付け例外を示します。 いずれの場合も、部品番号ゼロが有効であり、論理結果の先頭からできるだけ多くのレーンを保持し、物理出力コンテナの先頭に配置する演算に対応しています。 多くの場合、これは望ましいデフォルトであるため、部品番号ゼロはすべての場合において安全であり、ほとんどの場合に役立ちます。
このAPIの様々なサイズ変更演算は、次のようにデータを縮小または拡張します:
-
出力の「要素サイズ」が
M
の係数より大きい(またはより小さい)場合、Vector.convert()
はオペランドを比率M
で拡張(または縮小)します。 入力と出力の要素サイズが同じ場合、convert()
はインプレース演算です。 -
Vector.convertShape()
は、論理結果のビット・サイズが出力シェイプのビット・サイズより大きい(またはより小さい)場合、オペランドを比率M
で拡張(または縮小)します。 論理結果のサイズは、出力の「要素サイズ」にその入力のVLENGTH
を掛けたものとして定義されます。 変更されたレーンのサイズの比率に応じて、論理サイズは、演算が拡張であるか縮小であるかに関係なく、入力ベクトルより大きいか小さい(様々な場合)になります。 -
Vector.castShape()
はconvertShape()
の便利なメソッドであるため、拡張または縮小としての分類はconvertShape()
の場合と同じです。 -
Vector.reinterpretShape()
は、入力の「ベクトル・ビット・サイズ」がM
の係数でより小さい(それぞれ、より大きいサイズにドロップされます)出力コンテナにクラムされている場合の、比率M
による拡張(それぞれ縮小)です。 それ以外の場合は、インプレース演算です。 このメソッドは、レーンの境界を消去および再描画したり、シェイプを修正できる再解釈キャストであるため、入力ベクトル・レーン・サイズおよびレーン・カウントは、拡張または縮小としての分類とは無関係です。 -
単一の入力スライスが連続する複数のバックグラウンド・ベクトル内のどこかに配置および挿入されるため、
unslice()
メソッドはM=2
の比率で拡張されます。 パーツ番号は、挿入されたスライスによって更新された最初または2番目のバックグラウンド・ベクトルを選択します。 対応するslice()
メソッドは、unslice()
メソッドとは逆ですが、そのデータを縮小しないため、部品番号を必要としません。 これは、slice()
では、2つの入力ベクトルから抽出された正確なVLENGTH
レーンのスライスが提供されるためです。
VectorSpecies
上のメソッドpartLimit()
を使用して、提案された拡張または縮小のために部品パラメータの制限値を問い合せることができます。 partLimit()
から返される値は、拡張の場合は正の値、縮小の場合は負の値、インプレース演算の場合はゼロです。 その絶対値はパラメータ M
であるため、関連するメソッドの有効な部品番号引数に対する排他的な制限として機能します。 したがって、拡張の場合、partLimit()
値M
は部品番号の排他的な上限ですが、縮小の場合、partLimit()
値-M
は排他的なlower制限です。
レーン境界を越えたデータの移動
レーンの再描画や種の変更を行わないクロス・レーン方式は、より定期的に構造化され、より簡単に理由を理解できます。 操作は次のとおりです。- 連結されたベクトルのペア内の指定された原点から
VLENGTH
フィールドの連続したスライスを抽出するslice()
ファミリのメソッド。 - 指定された原点で連結されたベクトルのペアに
VLENGTH
フィールドの連続したスライスを挿入する、unslice()
ファミリのメソッド。 - メソッドの
rearrange()
ファミリ。いずれかまたは複数の入力ベクトルから任意のVLENGTH
レーンのセットを選択し、任意の順序でアセンブルします。 レーンの選択および順序は、搬送元レーンを搬送先レーンにマッピングするルーティング表として機能するVectorShuffle
オブジェクトによって制御されます。VectorShuffle
では、数学的順列および他の多くのデータ移動パターンをエンコードできます。
ベクトル演算の中には、レーンワイズではなく、レーン境界を越えてデータを移動するものがあります。 SIMDコードでは通常、このような演算はまれですが、低レベルでデータ形式を演算する特定のアルゴリズムや、複雑なローカル・パターンでの移動にSIMDデータが必要になる場合があります。 (大規模なデータ配列の小さいウィンドウでのローカル移動は比較的異常ですが、一部の高度にパターン化されたアルゴリズムによってコールされます。) このAPIでは、このようなメソッドは常に明確に認識できるため、より単純なレーンワイズ推論を残りのコードに確実に適用できます。
場合によっては、ベクトル・レーンの境界が破棄され、"最初から再描画"によって、特定の入力レーンのデータが複数の出力レーンを介して分散された(複数の部分)に表示されたり、複数の入力レーンの(逆)データが単一の出力レーンに統合されたりすることがあります。 レーン境界を再描画できる基本的なメソッドは、reinterpretShape()
です。 このメソッドの上に構築され、reinterpretAsBytes()
やreinterpretAsInts()
などの特定の便利なメソッドでは、同じベクトル全体のシェイプを維持しながら、レーン境界が(潜在的)で再描画されます。
スカラー結果を生成または消費する演算は、非常に単純なクロス・レーン演算とみなすことができます。 reduceLanes()
ファミリのメソッドは、メソッドのすべてのレーン(またはマスク選択されたレーン)をまとめて折りたたみ、単一の結果を返します。 逆に、broadcast
メソッド・ファミリは、スカラーから出力ベクトルのすべてのレーンまで、反対方向の横断レーンと考えることができます。 lane(I)
やwithLane(I,E)
などの単一レーンのアクセス・メソッドも、非常に単純なクロス・レーン演算とみなされる場合があります。
同様に、バイト配列との間で非バイト・ベクトルを移動するメソッドは、ベクトル・レーンを別々のバイトに分散するか、配列バイトから統合された(反対方向)に分散する必要があるため、クロス・レーン演算とみなすことができます。
- 実装上のノート:
ハードウェア・プラットフォームの依存性と制限
Vector APIは、ベクトル・ハードウェア・レジスタやベクトル・ハードウェア命令などの使用可能なハードウェア・リソースを使用して、単一命令複数データ(SIMD)のスタイルでの計算を高速化します。 このAPIは、複数のSIMDハードウェア・プラットフォームを効果的に使用するように設計されています。このAPIは、SIMD計算用の特殊なハードウェア・サポートが含まれていないJavaプラットフォームでも正しく機能します。 Vector APIでは、このようなプラットフォームで特別なパフォーマンス上の利点が得られない可能性があります。
現在、実装は次のものに最適化されています:
- AVX-512までのAVX2をサポートするIntel x64プラットフォーム。 AVX-512でのマスク・レジスタを使用したマスキングおよびハードウェア命令の受け入れは、現在サポートされていません。
- NEONをサポートするARM AArch64プラットフォーム。 APIはARM SVE命令が(128から2048ビットのベクトル・サイズ)をサポートできるように設計されていますが、現時点ではこのような命令の実装や一般的なマスキング機能はありません。
a.blend(a.lanewise(op, b), m)
のようにblend
で構成することで、クロス・プラットフォーム方式でのマスキングされたレーンワイズ演算がサポートされています。ここで、a
およびb
はベクトル、op
はベクトル演算子、m
はマスクです。現在の実装では、浮動小数点変換関数(
SIN
やLOG
などの演算子)に最適なベクトル化命令はサポートされていません。プリミティブのボクシングなし
Vector<Integer>
などのベクトル・タイプは、ボックス化されたInteger
値で動作するように見えますが、ボックス化に関連付けられたオーバーヘッドは、int
などの実際のETYPE
のレーン値で各Vectorサブタイプが内部的に機能することによって回避されます。値ベースのクラスとアイデンティティ演算
Vector
は、そのサブタイプおよびVectorMask
やVectorShuffle
などのヘルパー・タイプの多くとともに、value-basedクラスです。作成したベクトルは、「1つのレーンが変更された場合」のみであっても変更されません。 レーン値の新しい構成を保持するために、常に新しいベクトルが作成されます。 ミューチュアル・メソッドを使用できないことは、値ベースのクラスとしてすべてのベクトルのオブジェクト・アイデンティティを抑制した結果として必要です。
Vector
では、次のようになります。==
などのアイデンティティ依存の演算では、予期しない結果が発生したり、パフォーマンスが低下する可能性があります。equals
はアイデンティティ依存のメソッドではないため、v.equals(w)
はv==w
よりも高速である可能性が高くなります。 また、これらのオブジェクトは、ローカルおよびパラメータにもstatic final
定数としても格納できますが、意味的には有効ですが、他のJavaフィールドまたは配列要素に格納すると、パフォーマンスが低下する可能性があります。
-
メソッドのサマリー
修飾子と型メソッド説明abs()
このベクトルの絶対値を返します。このベクトルを2番目の入力ベクトルに追加します。add(Vector<E> v, VectorMask<E> m)
マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。addIndex(int scale)
指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。abstract int
bitSize()
このベクトルの合計サイズをビット単位で返します。blend(long e, VectorMask<E> m)
このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。blend(Vector<E> v, VectorMask<E> m)
このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。broadcast(long e)
すべてのレーン要素がプリミティブ値e
に設定されている、この種と同じ種のベクトルを返します。abstract int
byteSize()
このベクトルの合計サイズ(バイト単位)を返します。abstract <F> Vector<F>
castShape(VectorSpecies<F> rsp, int part)
ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。abstract <F> Vector<F>
このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。abstract <F> Vector<F>
check(VectorSpecies<F> species)
このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。abstract VectorMask<E>
compare(VectorOperators.Comparison op, long e)
指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。abstract VectorMask<E>
compare(VectorOperators.Comparison op, long e, VectorMask<E> m)
指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。abstract VectorMask<E>
compare(VectorOperators.Comparison op, Vector<E> v)
指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。abstract VectorMask<E>
compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)
このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。abstract <F> Vector<F>
convert(VectorOperators.Conversion<E,F> conv, int part)
指定された「変換」に従って、このベクトルを同じシェイプのベクトルおよび新しい要素タイプに変換し、レーン値を現在のETYPE
から新しいレーン型の(ここではFTYPE
と呼びます)に変換します。abstract <F> Vector<F>
convertShape(VectorOperators.Conversion<E,F> conv, VectorSpecies<F> rsp, int part)
指定された「変換」に従って、このベクトルを指定された種、シェイプ、および要素型のベクトルに変換し、レーン値を現在のETYPE
から新しいレーン型(ここではFTYPE
と呼びます)に変換します。このベクトルを2番目の入力ベクトルで除算します。div(Vector<E> v, VectorMask<E> m)
このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。abstract int
このベクトルの各レーンのサイズをビット単位で返します。このベクトルのプリミティブ「要素型」 (ETYPE
)を返します。abstract VectorMask<E>
このベクトルが別の入力ベクトルと等しいかどうかを判定します。abstract boolean
このベクトルが他のオブジェクトと同一かどうかを示します。abstract int
hashCode()
ベクトルのハッシュ・コード値を返します。abstract void
intoByteArray(byte[] a, int offset, ByteOrder bo)
明示的なバイト順序を使用して、オフセットから始まるバイト配列にこのベクトルを格納します。abstract void
intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<E> m)
明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。abstract void
intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)
明示的なバイト順序を使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。abstract void
intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<E> m)
明示的なバイト順序とマスクを使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。lanewise(VectorOperators.Binary op, long e)
このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。lanewise(VectorOperators.Binary op, long e, VectorMask<E> m)
このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。lanewise(VectorOperators.Binary op, Vector<E> v)
このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)
このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)
このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。このベクトルのレーン値を操作します。lanewise(VectorOperators.Unary op, VectorMask<E> m)
マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。abstract int
length()
レーン数または「ベクトル長さ」 (VLENGTH
)を返します。abstract VectorMask<E>
このベクトルが別の入力ベクトルより小さいかどうかを判定します。abstract VectorMask<E>
maskAll(boolean bit)
このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。このベクトルと2番目の入力ベクトルの大きい方を計算します。このベクトルと2番目の入力ベクトルの小さい方を計算します。このベクトルに2番目の入力ベクトルを掛けます。mul(Vector<E> v, VectorMask<E> m)
マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。neg()
このベクトルを否定します。rearrange(VectorShuffle<E> s)
特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。rearrange(VectorShuffle<E> s, Vector<E> v)
特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。rearrange(VectorShuffle<E> s, VectorMask<E> m)
特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。abstract long
このベクトルのすべてのレーンから累積された値を返します。abstract long
マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。abstract ByteVector
このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyte
では、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。abstract DoubleVector
このベクトルを、同じシェイプおよび内容でレーン型のdouble
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract FloatVector
このベクトルを、同じシェイプおよび内容でレーン型のfloat
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract IntVector
このベクトルを、同じシェイプおよび内容でレーン型のint
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract LongVector
このベクトルを、同じシェイプおよび内容でレーン型のlong
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract ShortVector
このベクトルを、同じシェイプおよび内容でレーン型のshort
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。abstract <F> Vector<F>
reinterpretShape(VectorSpecies<F> species, int part)
値の変換を実行せずに、このベクトルを要素型F
の指定された種のベクトルに変換し、このベクトルのバイトを再解釈します。selectFrom(Vector<E> v)
このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。selectFrom(Vector<E> v, VectorMask<E> m)
このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。abstract VectorShape
shape()
このベクトルのシェイプを返します。slice(int origin)
現在のベクトル内の指定されたorigin
レーンから始まる隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたorigin
レーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。slice(int origin, Vector<E> v1, VectorMask<E> m)
マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたorigin
レーンから開始し、(必要に応じて)を直後のベクトルに継続します。abstract VectorSpecies<E>
species()
このベクトルの種を返します。このベクトルから2番目の入力ベクトルを減算します。sub(Vector<E> v, VectorMask<E> m)
マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。abstract VectorMask<E>
test(VectorOperators.Test op)
指定された演算に従って、このベクトルのレーンをテストします。abstract VectorMask<E>
test(VectorOperators.Test op, VectorMask<E> m)
指定された演算に従って、このベクトルの選択されたレーンをテストします。abstract Object
toArray()
すべてのレーン値を含むパックされた配列を返します。abstract double[]
double
型に変換された、すべてのレーン値を含むdouble[]
配列を返します。abstract int[]
int
型に変換された、すべてのレーン値を含むint[]
配列を返します。abstract long[]
long
型に変換された、すべてのレーン値を含むlong[]
配列を返します。abstract VectorShuffle<E>
このベクトルをシャッフルに変換し、レーン値をint
に変換して、ソース索引として認識します。abstract String
toString()
このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"
形式のこのベクトルの文字列表現を返します。unslice(int origin)
slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。abstract Vector<?>
このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。abstract Vector<?>
このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。クラスjdk.internal.vm.vector.VectorSupport.VectorPayloadで宣言されたメソッド
getPayload
-
メソッドの詳細
-
species
public abstract VectorSpecies<E> species()このベクトルの種を返します。- 戻り値:
- このベクトルの種
-
elementType
このベクトルのプリミティブ「要素型」 (ETYPE
)を返します。- 実装要件:
- これは、
this.species().elementType()
と同じ値です。 - 戻り値:
- このベクトルのプリミティブ要素の型
-
elementSize
public abstract int elementSize()このベクトルの各レーンのサイズをビット単位で返します。- 実装要件:
- これは、
this.species().elementSize()
と同じ値です。 - 戻り値:
- このベクトルのレーンのサイズ(ビット単位)
-
shape
public abstract VectorShape shape()このベクトルのシェイプを返します。- 実装要件:
- これは、
this.species().vectorShape()
と同じ値です。 - 戻り値:
- このベクトルのシェイプ
-
length
public abstract int length()レーン数または「ベクトル長さ」 (VLENGTH
)を返します。- 戻り値:
- レーン数
-
bitSize
public abstract int bitSize()このベクトルの合計サイズをビット単位で返します。- 実装要件:
- これは、
this.shape().vectorBitSize()
と同じ値です。 - 戻り値:
- このベクトルの合計サイズ(ビット単位)
-
byteSize
public abstract int byteSize()このベクトルの合計サイズ(バイト単位)を返します。- 実装要件:
- これは、
this.bitSize()/Byte.SIZE
と同じ値です。 - 戻り値:
- このベクトルの合計サイズ(バイト単位)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Unary op)このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値の処理に使用される演算- 戻り値:
- 入力ベクトルにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
VectorOperators.NEG
,VectorOperators.NOT
,VectorOperators.SIN
,lanewise(VectorOperators.Unary,VectorMask)
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Ternary,Vector,Vector)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Unary op, VectorMask<E> m)マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値の処理に使用される演算m
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Unary)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Binary op, Vector<E> v)このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値を結合するために使用される演算v
- 入力ベクトル- 戻り値:
- 2つの入力ベクトルにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
VectorOperators.ADD
,VectorOperators.XOR
,VectorOperators.ATAN2
,lanewise(VectorOperators.Binary,Vector,VectorMask)
,lanewise(VectorOperators.Unary)
,lanewise(VectorOperators.Ternary,Vector, Vector)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値を結合するために使用される演算v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 2つの入力ベクトルにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Binary,Vector)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Binary op, long e)このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e))
。- APIのノート:
e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールは、broadcast()
への暗黙的なコールによって適用されます。サブタイプは、メソッドの戻り型とスカラー・パラメータ
e
の型をシャープにすることで、このメソッドで改善されます。- パラメータ:
op
- レーン値を結合するために使用される演算e
- 入力スカラー- 戻り値:
- 入力ベクトルとスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合IllegalArgumentException
- 指定されたlong
値をベクトル演算の右側のオペランド型で表現できない場合- 関連項目:
broadcast(long)
,lanewise(VectorOperators.Binary,long,VectorMask)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Binary op, long e, VectorMask<E> m)このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。 2番目のオペランドはブロードキャスト整数値です。 戻り値はこの式と等しくなります:this.lanewise(op, this.broadcast(e), m)
。- APIのノート:
e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールは、broadcast()
への暗黙的なコールによって適用されます。サブタイプは、メソッドの戻り型とスカラー・パラメータ
e
の型をシャープにすることで、このメソッドで改善されます。- パラメータ:
op
- レーン値を結合するために使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 入力ベクトルとスカラーにレーンワイズ演算を適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合IllegalArgumentException
- 指定されたlong
値をベクトル演算の右側のオペランド型で表現できない場合- 関連項目:
broadcast(long)
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
lanewise
このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。 これは、選択した演算を各レーンに適用するレーンワイズの三項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値を結合するために使用される演算v1
- 2番目の入力ベクトルv2
- 3番目の入力ベクトル- 戻り値:
- 3つの入力ベクトルに演算レーンワイズを適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
VectorOperators.BITWISE_BLEND
,VectorOperators.FMA
,lanewise(VectorOperators.Unary)
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
-
lanewise
public abstract Vector<E> lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。 これは、選択した演算を各レーンに適用するレーンワイズ三項演算です。- APIのノート:
- サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
- パラメータ:
op
- レーン値を結合するために使用される演算v1
- 2番目の入力ベクトルv2
- 3番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 3つの入力ベクトルに演算レーンワイズを適用した結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
lanewise(VectorOperators.Ternary,Vector,Vector)
-
add
このベクトルを2番目の入力ベクトルに追加します。 これは、プリミティブ加算演算(+
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
ADD
, v)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルを2番目の入力ベクトルに加算した結果
- 関連項目:
add(Vector,VectorMask)
,IntVector.add(int)
,VectorOperators.ADD
,lanewise(VectorOperators.Binary,Vector)
,IntVector.lanewise(VectorOperators.Binary,int)
-
add
マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。 これは、対応するレーン値の各ペアにプリミティブ加算演算(+
)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
ADD
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 指定されたベクトルにこのベクトルを追加した結果
- 関連項目:
add(Vector)
,IntVector.add(int,VectorMask)
,VectorOperators.ADD
,lanewise(VectorOperators.Binary,Vector,VectorMask)
,IntVector.lanewise(VectorOperators.Binary,int,VectorMask)
-
sub
このベクトルから2番目の入力ベクトルを減算します。 これは、プリミティブ減算演算(-
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
SUB
, v)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルから2番目の入力ベクトルを減算した結果
- 関連項目:
sub(Vector,VectorMask)
,IntVector.sub(int)
,VectorOperators.SUB
,lanewise(VectorOperators.Binary,Vector)
,IntVector.lanewise(VectorOperators.Binary,int)
-
sub
マスクの制御下で、このベクトルから2つ目の入力ベクトルを減算します。 これは、対応するレーン値の各ペアにプリミティブ減算演算(-
)を適用する、マスクされたレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
SUB
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルから2番目の入力ベクトルを減算した結果
- 関連項目:
sub(Vector)
,IntVector.sub(int,VectorMask)
,VectorOperators.SUB
,lanewise(VectorOperators.Binary,Vector,VectorMask)
,IntVector.lanewise(VectorOperators.Binary,int,VectorMask)
-
mul
このベクトルに2番目の入力ベクトルを掛けます。 これは、プリミティブ乗算演算(*
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MUL
, v)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルに2番目の入力ベクトルを掛けた結果
- 関連項目:
mul(Vector,VectorMask)
,IntVector.mul(int)
,VectorOperators.MUL
,lanewise(VectorOperators.Binary,Vector)
,IntVector.lanewise(VectorOperators.Binary,int)
-
mul
マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。 これは、プリミティブ乗算演算(*
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
MUL
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルに指定されたベクトルを掛けた結果
- 関連項目:
mul(Vector)
,IntVector.mul(int,VectorMask)
,VectorOperators.MUL
,lanewise(VectorOperators.Binary,Vector,VectorMask)
,IntVector.lanewise(VectorOperators.Binary,int,VectorMask)
-
div
このベクトルを2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
DIV
, v)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- APIのノート:
- 基本となるスカラー演算子がゼロ除算をサポートしていないが、ゼロ除数で表示される場合は、
ArithmeticException
がスローされます。 - パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルを2番目の入力ベクトルで割った結果
- 例外:
ArithmeticException
-v
のレーンがゼロで、ETYPE
がfloat
またはdouble
でない場合。- 関連項目:
div(Vector,VectorMask)
,DoubleVector.div(double)
,VectorOperators.DIV
,lanewise(VectorOperators.Binary,Vector)
,IntVector.lanewise(VectorOperators.Binary,int)
-
div
このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。 これは、プリミティブ除算演算(/
)を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 マスクに設定されていないレーンについては、プリミティブ演算は抑制され、このベクトルはそのレーンに格納されている元の値を保持します。 このメソッドは、式lanewise
(
DIV
, v, m)
とも同じです。フル・サービスの名前付き演算として、このメソッドはマスキングされたオーバーロードおよびマスキングされていないオーバーロードで使用され、(サブクラス)もスカラー・ブロードキャストのオーバーロード(マスク済とマスク解除済の両方)で使用されます。
- APIのノート:
- 基本となるスカラー演算子がゼロ除算をサポートしていないが、ゼロ除数で表示される場合は、
ArithmeticException
がスローされます。 - パラメータ:
v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- このベクトルを2番目の入力ベクトルで割った結果
- 例外:
ArithmeticException
-v
でm
によって選択されたレーンがゼロで、ETYPE
がfloat
またはdouble
でない場合。- 関連項目:
div(Vector)
,DoubleVector.div(double,VectorMask)
,VectorOperators.DIV
,lanewise(VectorOperators.Binary,Vector,VectorMask)
,DoubleVector.lanewise(VectorOperators.Binary,double,VectorMask)
-
neg
- APIのノート:
- このメソッドにはマスクされたバリアントはありませんが、対応するマスクされた演算は「レーンに関するメソッド」から取得できます。
- 戻り値:
- このベクトルの否定
- 関連項目:
VectorOperators.NEG
,lanewise(VectorOperators.Unary)
,lanewise(VectorOperators.Unary,VectorMask)
-
abs
- APIのノート:
- このメソッドにはマスクされたバリアントはありませんが、対応するマスクされた演算は「レーンに関するメソッド」から取得できます。
- 戻り値:
- このベクトルの絶対値
- 関連項目:
VectorOperators.ABS
,lanewise(VectorOperators.Unary)
,lanewise(VectorOperators.Unary,VectorMask)
-
min
このベクトルと2番目の入力ベクトルの小さい方を計算します。 これは、演算Math.min()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MIN
, v)
とも同じです。- APIのノート:
- これは、
add()
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。 サブクラスは、このメソッドの追加のスカラー・ブラ・ド キャスト・オーバーロードを定義します。 - パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン最小値
- 関連項目:
IntVector.min(int)
,VectorOperators.MIN
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
max
このベクトルと2番目の入力ベクトルの大きい方を計算します。 これは、演算Math.max()
を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise
(
MAX
, v)
とも同じです。これは、
add()
のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewise
を介して取得できます。 サブクラスは、このメソッドの追加のスカラー・ブラ・ド キャスト・オーバーロードを定義します。- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン方向の最大値
- 関連項目:
IntVector.max(int)
,VectorOperators.MAX
,lanewise(VectorOperators.Binary,Vector)
,lanewise(VectorOperators.Binary,Vector,VectorMask)
-
reduceLanesToLong
public abstract long reduceLanesToLong(VectorOperators.Associative op)このベクトルのすべてのレーンから累積された値を返します。 これは、指定された演算をすべてのレーン要素に適用する、関連するクロス・レーン削減演算です。 戻り値はこの式と等しくなります:(long) ((EVector)this).reduceLanes(op)
。EVector
は、このベクトル要素タイプETYPE
に固有のベクトル・クラスです。ADD
およびMUL
の演算では、ETYPE
がfloat
またはdouble
の場合、キャスト前の正確な結果には、時間の経過とともに変化する可能性がある任意の順序の演算の選択が反映されます。 詳細は、「浮動小数点ベクトルに対する演算」の項を参照してください。- APIのノート:
ETYPE
がfloat
またはdouble
の場合、この演算はlong
への結果のキャストの通常の部分として精度または範囲(あるいはその両方)を失う可能性があります。 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。- パラメータ:
op
- レーン値を結合するために使用される演算- 戻り値:
- 累積結果、
long
へのキャスト - 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
reduceLanesToLong(VectorOperators.Associative,VectorMask)
,IntVector.reduceLanes(VectorOperators.Associative)
,FloatVector.reduceLanes(VectorOperators.Associative)
-
reduceLanesToLong
public abstract long reduceLanesToLong(VectorOperators.Associative op, VectorMask<E> m)マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。 これは、指定した工程を選択したレーン要素に適用する、関連するクロス・レーン短縮演算です。 戻り値はこの式と等しくなります:(long) ((EVector)this).reduceLanes(op, m)
。EVector
は、このベクトル要素タイプETYPE
に固有のベクトル・クラスです。要素が選択されていない場合は、演算固有のアイデンティティ値が返されます。
-
演算が
ADD
、XOR
またはOR
の場合、アイデンティティ値はゼロです。 -
演算が
MUL
の場合、アイデンティティ値はいずれかです。 -
演算が
AND
の場合、アイデンティティ値は単一の(すべてのビット・セット)を引いた値になります。 -
演算が
MAX
の場合、アイデンティティ値はベクトル・ネイティブETYPE
のMIN_VALUE
です。 (浮動小数点型の場合、値NEGATIVE_INFINITY
が使用され、Long.MIN_VALUE
としてキャストされた後に表示されます。 -
演算が
MIN
の場合、アイデンティティ値はベクトル・ネイティブETYPE
のMAX_VALUE
です。 (浮動小数点型の場合、値POSITIVE_INFINITY
が使用され、Long.MAX_VALUE
としてキャストされた後に表示されます。
ADD
およびMUL
の演算では、ETYPE
がfloat
またはdouble
の場合、キャスト前の正確な結果には、時間の経過とともに変化する可能性がある任意の順序の演算の選択が反映されます。 詳細は、「浮動小数点ベクトルに対する演算」の項を参照してください。- APIのノート:
ETYPE
がfloat
またはdouble
の場合、この演算はlong
への結果のキャストの通常の部分として精度または範囲(あるいはその両方)を失う可能性があります。 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。- パラメータ:
op
- レーン値を結合するために使用される演算m
- マスク制御レーンの選択- 戻り値:
- 選択されたレーン値から累積された還元結果
- 例外:
UnsupportedOperationException
- このベクトルがリクエストされた演算をサポートしていない場合- 関連項目:
reduceLanesToLong(VectorOperators.Associative)
,IntVector.reduceLanes(VectorOperators.Associative,VectorMask)
,FloatVector.reduceLanes(VectorOperators.Associative,VectorMask)
-
演算が
-
test
public abstract VectorMask<E> test(VectorOperators.Test op)指定された演算に従って、このベクトルのレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用するレーンワイズ単項テスト演算です。- パラメータ:
op
- レーン値のテストに使用される演算- 戻り値:
- 選択されたテスト演算子に従って、このベクトルのレーンをテストしたマスク結果
- 関連項目:
VectorOperators.Comparison
,test(VectorOperators.Test, VectorMask)
,compare(VectorOperators.Comparison, Vector)
-
test
public abstract VectorMask<E> test(VectorOperators.Test op, VectorMask<E> m)指定された演算に従って、このベクトルの選択されたレーンをテストします。 これは、指定されたテスト演算を各レーン値に適用する、マスクされたレーンワイズ単項テスト演算です。 返される結果は、式test(op).and(m)
と同じです。- パラメータ:
op
- レーン値のテストに使用される演算m
- マスク制御レーンの選択- 戻り値:
- 選択されたテスト演算子に従って、マスクによって選択されたレーン内でのみ、このベクトルのレーンをテストしたマスク結果
- 関連項目:
test(VectorOperators.Test)
-
eq
public abstract VectorMask<E> eq(Vector<E> v)このベクトルが別の入力ベクトルと等しいかどうかを判定します。 これは、プリミティブ等価演算(==
)を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.EQ, v)
と同じです。- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルが2番目の入力ベクトルと等しいかどうかをレーンワイズ判定した結果のマスク
- 関連項目:
compare(VectorOperators.Comparison,Vector)
,VectorOperators.EQ
,equals(java.lang.Object)
-
lt
public abstract VectorMask<E> lt(Vector<E> v)このベクトルが別の入力ベクトルより小さいかどうかを判定します。 これは、プリミティブなより小さい演算の(<
)を各レーンに適用するレーンワイズ二項テスト演算です。 結果はcompare(VectorOperators.LT, v)
と同じです。- パラメータ:
v
- 2番目の入力ベクトル- 戻り値:
- このベクトルが2番目の入力ベクトルより小さい場合のレーンワイズ・テストのマスク結果
- 関連項目:
compare(VectorOperators.Comparison,Vector)
,VectorOperators.LT
-
compare
public abstract VectorMask<E> compare(VectorOperators.Comparison op, Vector<E> v)指定された比較演算に従って別の入力ベクトルと比較することによって、このベクトルをテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用するレーンワイズ二項テスト演算です。- パラメータ:
op
- レーン値の比較に使用される演算v
- 2番目の入力ベクトル- 戻り値:
- 選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
- 関連項目:
eq(Vector)
,lt(Vector)
,VectorOperators.Comparison
,compare(VectorOperators.Comparison, Vector, VectorMask)
,test(VectorOperators.Test)
-
compare
public abstract VectorMask<E> compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)このベクトルを、指定された比較演算に従って、マスクによって選択されたレーン内の別の入力ベクトルと比較してテストします。 これは、指定された比較演算を対応するレーン値の各ペアに適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,v).and(m)
と同じです。- パラメータ:
op
- レーン値の比較に使用される演算v
- 2番目の入力ベクトルm
- マスク制御レーンの選択- 戻り値:
- 選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
- 関連項目:
compare(VectorOperators.Comparison, Vector)
-
compare
public abstract VectorMask<E> compare(VectorOperators.Comparison op, long e)指定された比較演算に従って入力スカラーと比較することによって、このベクトルをテストします。 これは、ブロードキャスト値とペアになっている各レーン値に特定の比較演算を適用するレーンワイズ二項テスト演算です。結果は
this.compare(op, this.broadcast(e))
と同じです。 つまり、スカラーは、同じ種のベクトルにブロードキャストされたとみなされ、選択された比較演算を使用して元のベクトルと比較されます。- APIのノート:
e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールは、broadcast()
への暗黙的なコールによって適用されます。サブタイプは、スカラー・パラメータ
e
のタイプをシャープにすることで、このメソッドで改善されます。- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラー- 戻り値:
- 選択された比較演算子に従って、このベクトルが入力と比較される場合のレーンワイズ・テストのマスク結果
- 例外:
IllegalArgumentException
- 指定されたlong
値をベクトルETYPE
で表現できない場合- 関連項目:
broadcast(long)
,compare(VectorOperators.Comparison,Vector)
-
compare
public abstract VectorMask<E> compare(VectorOperators.Comparison op, long e, VectorMask<E> m)指定された比較演算に従って、マスクによって選択されたレーン単位で入力スカラーと比較することによって、このベクトルをテストします。 これは、指定された比較演算をブロードキャスト値とペアにして各レーン値に適用する、マスクされたレーンワイズ二項テスト演算です。 返される結果は、式compare(op,e).and(m)
と同じです。- APIのノート:
e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールは、broadcast()
への暗黙的なコールによって適用されます。サブタイプは、スカラー・パラメータ
e
のタイプをシャープにすることで、このメソッドで改善されます。- パラメータ:
op
- レーン値の比較に使用される演算e
- 入力スカラーm
- マスク制御レーンの選択- 戻り値:
- 選択された比較演算子に従って、およびマスクによって選択されたレーンでのみ、このベクトルが入力と比較されるかどうかをレーンワイズ・テストしたときのマスク結果
- 例外:
IllegalArgumentException
- 指定されたlong
値をベクトルETYPE
で表現できない場合- 関連項目:
broadcast(long)
,compare(VectorOperators.Comparison,Vector)
-
blend
このベクトルの選択されたレーンを、マスクの制御下にある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);
- パラメータ:
v
- 置換レーン値を含む2番目の入力ベクトルm
- 2番目の入力ベクトルからのマスク制御レーンの選択- 戻り値:
- このベクトルのレーン要素を2番目の入力ベクトルのレーン要素とブレンドした結果
-
blend
public abstract Vector<E> blend(long e, VectorMask<E> m)このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。 これは、一方の入力から各レーン値を選択する、マスクされたレーンワイズ二項演算です。 返される結果は、式blend(broadcast(e),m)
と同じです。- APIのノート:
e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールは、broadcast()
への暗黙的なコールによって適用されます。サブタイプは、スカラー・パラメータ
e
のタイプをシャープにすることで、このメソッドで改善されます。- パラメータ:
e
- 置換レーン値を含む入力スカラーm
- スカラーのマスク制御レーンの選択- 戻り値:
- このベクトルのレーン要素をスカラー値とブレンドした結果
-
addIndex
指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。 これはレーンワイズ単項演算で、レーン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);
- パラメータ:
scale
- 各レーン索引N
で乗算する数(通常は1
)- 戻り値:
scale
によってスケーリングされた、各レーン要素を対応するレーン索引N
で増分した結果- 例外:
IllegalArgumentException
- 間隔[0..VLENGTH*scale]
の値がETYPE
で表現できない場合
-
slice
現在のベクトル内の指定された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
を返します。- APIのノート:
- このメソッドは、次の疑似コードのように、関連しない要素を妨げることなく、スライスされた値を2つの入力ベクトルの元の位置に非表示にできるという点で、
unslice()
の逆とみなすことができます:EVector slice = v1.slice(origin, v2); EVector w1 = slice.unslice(origin, v1, 0); EVector w2 = slice.unslice(origin, v2, 1); assert v1.equals(w1); assert v2.equals(w2);
このメソッドでは、次のような様々なクロス・レーンのシフトおよび回転もサポートされます:
- レーンをベクトルの前にシフトするには、2番目のオペランドにゼロのベクトルを指定し、原点としてシフト・カウントを指定します。 例えば:
v.slice(shift, v.broadcast(0))
。 - レーンをベクトルの後ろにシフトするには、firstオペランドにゼロのベクトルを指定し、負のシフト数を起点(モジュロ
VLENGTH
)として指定します。 例えば:v.broadcast(0).slice(v.length()-shift, v)
。 - ベクトルのフロントエンドに向かってレーンを前方に回転し、最も古いレーンを後方に循環させるには、両方のオペランドに同じベクトルを指定し、回転数を原点として指定します。 例えば:
v.slice(rotate, v)
。 - ベクトルのバックエンドに向かってレーンを後方に回転させるには、最新のレーンを前方に循環させ、両方のオペランドに同じベクトルを指定して、回転カウント(modulo
VLENGTH
)の負の数を原点として指定します。 例えば:v.slice(v.length() - rotate, v)
。 -
ゼロ未満または
VLENGTH
を超えるorigin
値は拒否されるため、VLENGTH
の予測不可能な倍数でローテーションする必要がある場合は、必ず元の値を必要な範囲に減らしてください。 これには、loopBound()
メソッドが役立ちます。 例えば:v.slice(rotate - v.species().loopBound(rotate), v)
。
- レーンをベクトルの前にシフトするには、2番目のオペランドにゼロのベクトルを指定し、原点としてシフト・カウントを指定します。 例えば:
- パラメータ:
origin
- スライスに転送する最初の入力レーンv1
- スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトル- 戻り値:
- 指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得された
VLENGTH
レーンの連続するスライス - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合- 関連項目:
slice(int,Vector,VectorMask)
,slice(int)
,unslice(int,Vector,int)
-
slice
マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたorigin
レーンから開始し、(必要に応じて)を直後のベクトルに継続します。VLENGTH
レーンのブロックが独自のベクトルに抽出され、返されます。 結果のベクトルは、指定されたマスクで設定されていないすべてのレーンでゼロになります。 マスクに設定されたレーンには、this
またはv1
の選択したレーンからコピーされたデータが含まれます。これは、レーン要素を現在のベクトルと2番目のベクトルの間で正面に移動するクロス・レーン演算です。 どちらのベクトルも、スライスの抽出元となる長さ
2*VLENGTH
の結合"background"として表示できます。 返される結果は、式broadcast(0).blend(slice(origin,v1),m)
と同じです。- APIのノート:
- このメソッドは、次の疑似コードのように、関連しない要素を妨げることなく、スライスされた値を2つの入力ベクトルの元の位置に非表示にできるという点で、
#unslice(int,Vector,int,VectorMask) unslice()
の逆とみなすことができます:EVector slice = v1.slice(origin, v2, m); EVector w1 = slice.unslice(origin, v1, 0, m); EVector w2 = slice.unslice(origin, v2, 1, m); assert v1.equals(w1); assert v2.equals(w2);
- パラメータ:
origin
- スライスに転送する最初の入力レーンv1
- スライスが(省略すると、デフォルトでゼロに設定されます)とみなされる前に、最初のベクトルと論理的に連結されたもう一方のベクトルm
- 結果のベクトルへのマスク制御レーンの選択- 戻り値:
- 指定された原点から開始し、(必要に応じて)を2番目のベクトルに継続する、このベクトルから取得された
VLENGTH
レーンの連続するスライス - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合- 関連項目:
slice(int,Vector)
,unslice(int,Vector,int,VectorMask)
-
slice
現在のベクトル内の指定されたorigin
レーンから始まる隣接レーンのセグメントをスライスします。VLENGTH
レーンのブロック(おそらくゼロのレーンが埋め込まれている)は、独自のベクトルに抽出されて返されます。 これは、ゼロ・レーンの拡張バックグラウンドに対して単一ベクトルからスライスする便利なメソッドです。 これは、slice
(origin,
broadcast
(0))
と同等です。 また、単に、ベクトルの終点にゼロが必要なレーンを埋めて、後のレーンから前のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はorigin
です。- パラメータ:
origin
- スライスに転送する最初の入力レーン- 戻り値:
- 出力の最初のレーンから始まり、末尾にゼロが埋め込まれた最後の
VLENGTH-origin
入力レーン - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合- 関連項目:
slice(int,Vector)
,unslice(int,Vector,int)
-
unslice
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
を返します。- APIのノート:
- このメソッドでは、次のような様々なクロス・レーン挿入演算がサポートされています:
- バックグラウンド・ベクトル
w
の終端付近のあるオフセット位置に挿入するには、オフセットを原点として指定し、パーツ・ゼロを選択します。 例えば:v.unslice(offset, w, 0)
。 - バックグラウンド・ベクトル
w
の末尾付近に挿入するが、オーバーフローを次のベクトルx
に取り込むには、オフセットを原点として指定し、パート1を選択します。 例えば:v.unslice(offset, x, 1)
。 - バックグラウンド・ベクトル
w
の先頭付近に最後のN
品目を挿入するには、VLENGTH-N
を原点として指定し、部品を選択します。 例えば:v.unslice(v.length()-N, w)
。
- バックグラウンド・ベクトル
- パラメータ:
origin
- スライスを受け取る最初の出力レーンw
- (2つのコピーとして)が挿入されたスライスを受け取るバックグラウンド・ベクトルpart
- 結果(ゼロまたは1つ)のパート番号- 戻り値:
- 指定された原点にこのベクトルを挿入して更新された、バックグラウンド・ベクトルのペア
w
の最初または2番目の部分 - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合、あるいはpart
がゼロまたはいずれでもない場合- 関連項目:
slice(int,Vector)
,unslice(int,Vector,int,VectorMask)
-
unslice
slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()
演算に対する一方または他方の入力とみなされます。これは、現在のベクトルのレーン要素を前方に通し、そのレーン(マスクによって選択された場合)をバックグラウンド・ベクトルの論理ペアに挿入するクロス・レーン演算です。 このメソッドの「マスクされていないバージョン」と同様に、
part
番号で選択されたペアのいずれか一方のみが返されます。 マスクによって選択されたレーンN
ごとに、レーン値が最初のバックグラウンド・ベクトルのレーンorigin+N
にコピーされます(そのレーンが存在する場合)。それ以外の場合は、2番目のバックグラウンド・ベクトル(存在することが保証されています)のレーンorigin+N-VLENGTH
にコピーされます。 対応する入力レーンN
がマスクで設定解除されている場合、バックグラウンド・レーンは元の値を保持します。 挿入されたスライスのセット・レーンで更新された最初または2番目のバックグラウンド・ベクトルが返されます。part
の数値がゼロまたは1の場合は、最初または2番目に更新されたバックグラウンド・ベクトルが選択されます。- パラメータ:
origin
- スライスを受け取る最初の出力レーンw
- 挿入されたスライスがm
で設定されている場合に、(2つのコピーとして)が受け取るバックグラウンド・ベクトルpart
- 結果(ゼロまたは1つ)のパート番号m
- 現在のベクトルからのマスク制御レーンの選択- 戻り値:
- 指定された原点にこのベクトルの選択されたレーンを挿入することで更新された、バックグラウンド・ベクトルのペア
w
の最初または2番目の部分 - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合、あるいはpart
がゼロまたはいずれでもない場合- 関連項目:
unslice(int,Vector,int)
,slice(int,Vector)
-
unslice
slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。 他のunslice()
メソッドと比較して、このメソッドはバックグラウンド・ベクトルのペアの最初のメソッドのみを返します。 これは、unslice
(origin,
broadcast
(0), 0)
の結果を返す簡易メソッドです。 また、単に、ベクトルの始点で必要なレーンがゼロで塗りつぶされた、前のレーンから後のレーンへの横断シフトとして表示されることもあります。 このビューでは、シフト数はorigin
です。- パラメータ:
origin
- スライスを受け取る最初の出力レーン- 戻り値:
- 指定された原点から始まり、先頭にゼロが埋め込まれた最初の
VLENGTH-origin
入力レーン - 例外:
ArrayIndexOutOfBoundsException
-origin
が負またはVLENGTH
より大きい場合- 関連項目:
unslice(int,Vector,int)
,slice(int)
-
rearrange
public abstract Vector<E> rearrange(VectorShuffle<E> s)特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。 これは、このベクトルのレーン要素を再配置するクロス・レーン演算です。 シャッフルのレーンN
ごと、およびシャッフル内のレーンのソース索引I=s.laneSource(N)
ごとに、出力レーンN
はレーンI
の入力ベクトルから値を取得します。- パラメータ:
s
- シャッフル・コント・ローリング・レーン索引の選択- 戻り値:
- このベクトルのレーン要素の再配置
- 例外:
IndexOutOfBoundsException
- シャッフルに例外的なソース索引がある場合- 関連項目:
rearrange(VectorShuffle,VectorMask)
,rearrange(VectorShuffle,Vector)
,VectorShuffle.laneIsValid()
-
rearrange
public abstract Vector<E> rearrange(VectorShuffle<E> s, VectorMask<E> 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);
- パラメータ:
s
- シャッフル・コント・ローリング・レーン索引の選択m
- シャッフルの適用を制御するマスク- 戻り値:
- このベクトルのレーン要素の再配置
- 例外:
IndexOutOfBoundsException
- マスクが設定されているシャッフルに例外的なソース・インデックスがある場合- 関連項目:
rearrange(VectorShuffle)
,rearrange(VectorShuffle,Vector)
,VectorShuffle.laneIsValid()
-
rearrange
特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、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());
- パラメータ:
s
- 両方の入力ベクトルからのシャッフル制御レーンの選択v
- 2番目の入力ベクトル- 戻り値:
- このベクトルと2番目の入力ベクトルのレーン要素の再配置
- 関連項目:
rearrange(VectorShuffle)
,rearrange(VectorShuffle,VectorMask)
,VectorShuffle.laneIsValid()
,slice(int,Vector)
-
selectFrom
このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 これは、このベクトルの制御下で引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 このベクトルのレーンN
ごと、およびこのベクトルのレーン値I=this.lane(N)
ごとに、出力レーンN
はレーンI
の引数ベクトルから値を取得します。 このようにすると、結果には引数ベクトルv
に格納されている値のみが含まれますが、this
の索引値に依存する順序で表示されます。 結果は、式v.rearrange(this.toShuffle())
と同じです。- パラメータ:
v
- 結果値を提供するベクトル- 戻り値:
v
のレーン要素の再配置- 例外:
IndexOutOfBoundsException
-this
で無効なソース索引が検出された場合- 関連項目:
rearrange(VectorShuffle)
-
selectFrom
このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。 このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルv
に格納されている値をアセンブルします。 したがって、2番目のベクトルは表として機能し、その要素は現在のベクトルのインデックスによって選択されます。 マスクで設定されていないレーンは、表からの値ではなくゼロを受け取ります。 これは、このベクトルとマスクの制御下で、引数ベクトルのレーン要素を再配置するクロス・レーン演算です。 結果は、式v.rearrange(this.toShuffle(), m)
と同じです。- パラメータ:
v
- 結果値を提供するベクトルm
-v
からの選択を制御するマスク- 戻り値:
v
のレーン要素の再配置- 例外:
IndexOutOfBoundsException
-this
で、マスクに設定されているレーンに無効なソース索引が見つかった場合- 関連項目:
selectFrom(Vector)
,rearrange(VectorShuffle,VectorMask)
-
broadcast
すべてのレーン要素がプリミティブ値e
に設定されている、この種と同じ種のベクトルを返します。 現在のベクトルの内容は破棄されます。この演算に関連するのは種だけです。このメソッドは、この式の値を戻します:
EVector.broadcast(this.species(), (ETYPE)e)
。EVector
は、このベクトル要素タイプETYPE
に固有のベクトル・クラスです。e==(long)(ETYPE)e
になるように、long
値e
は、このベクトル種のETYPE
によって正確に表現可能である必要があります。 このルールに違反すると、問題は静的に検出されませんが、実行時にIllegalArgumentException
がスローされます。 したがって、このメソッドは、直接の定数およびその他のスカラーの静的な型チェックを若干弱めますが、汎用APIの表現性を向上させることでこれを実現します。 すべてのETYPE
はすべてのbyte
値を受け入れるため、[-128..127]
の範囲内のe
値は常に受け入れられます。- APIのノート:
- サブタイプは、メソッドの戻り値の型とスカラー・パラメータ
e
の型をシャープにすることで、このメソッドで改善されます。 - パラメータ:
e
- ブロードキャストする値- 戻り値:
- すべてのレーン要素がプリミティブ値
e
に設定されているベクトル - 例外:
IllegalArgumentException
- 指定されたlong
値をベクトルETYPE
で表現できない場合- 関連項目:
VectorSpecies.broadcast(long)
,IntVector.broadcast(int)
,FloatVector.broadcast(float)
-
maskAll
public abstract VectorMask<E> maskAll(boolean bit)このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。このメソッドは、この式の値を戻します:
species().maskAll(bit)
。- パラメータ:
bit
- 複製される指定されたマスク・ビット- 戻り値:
- 指定されたビットに従って各レーンが設定または設定解除されるマスク
- 関連項目:
VectorSpecies.maskAll(boolean)
-
toShuffle
public abstract VectorShuffle<E> toShuffle()このベクトルをシャッフルに変換し、レーン値をint
に変換して、ソース索引として認識します。このメソッドは、ベクトル要素の配列を指定してシャッフルを作成した結果を返すかのように動作します:
long[] a = this.toLongArray(); int[] sa = new int[a.length]; for (int i = 0; i < a.length; i++) { sa[i] = (int) a[i]; } return VectorShuffle.fromValues(this.species(), sa);
- 戻り値:
- このベクトルのシャッフル表現
- 関連項目:
VectorShuffle.fromValues(VectorSpecies,int...)
-
reinterpretShape
public abstract <F> Vector<F> reinterpretShape(VectorSpecies<F> species, int part)値の変換を実行せずに、このベクトルを要素型F
の指定された種のベクトルに変換し、このベクトルのバイトを再解釈します。選択した種によっては、この演算によって「拡大または縮小」の論理結果が生成される場合があります。その場合は、ゼロ以外の
part
番号を使用して、論理結果の選択および物理出力ベクトルへのリングをさらに制御できます。このベクトルのベースとなるビットは変更なしで結果のベクトルにコピーされますが、コピー前に、このベクトルのビット・サイズが目的のベクトルのビット・サイズより大きい場合は切り捨てられ、このベクトルのビット・サイズが目的のベクトルのビット・サイズより小さい場合はゼロのビットで埋められます。
新旧の種のシェイプが異なる場合、これはshape-changing演算であり、特別な実装コストがかかる可能性があります。
このメソッドは、リトル・エンディアン・バイト順序を使用してこのベクトルがbyteバッファまたは配列に格納されているかのように動作し、その後、同じバイト順序を使用して同じbyteバッファまたは配列から目的のベクトルがロードされます。
次の疑似コードは、この動作を示しています:
int domSize = this.byteSize(); int ranSize = species.vectorByteSize(); int M = (domSize > ranSize ? domSize / ranSize : ranSize / domSize); assert Math.abs(part) < M; assert (part == 0) || (part > 0) == (domSize > ranSize); byte[] ra = new byte[Math.max(domSize, ranSize)]; if (domSize > ranSize) { // expansion this.intoByteArray(ra, 0, ByteOrder.native()); int origin = part * ranSize; return species.fromByteArray(ra, origin, ByteOrder.native()); } else { // contraction or size-invariant int origin = (-part) * domSize; this.intoByteArray(ra, origin, ByteOrder.native()); return species.fromByteArray(ra, 0, ByteOrder.native()); }
- APIのノート:
- このメソッドは、問題のベクトルがメモリーにロードまたは格納されたかのように定義されますが、メモリー・セマンティクスは実際の実装とほとんど関係がないか、まったく関係がありません。 リトル・エンディアン順序付けへのアピールは、レーン構造化ベクトルとバイト構造化ベクトル間のマッピングに関連する多数の詳細ルールになる可能性のあるものの短縮形です。
- 型パラメータ:
F
- 種のboxed要素の型- パラメータ:
species
- 目的のベクトル種part
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルからシェイプおよび要素型によって変換されたベクトル
- 関連項目:
convertShape(VectorOperators.Conversion,VectorSpecies,int)
,castShape(VectorSpecies,int)
,VectorSpecies.partLimit(VectorSpecies,boolean)
-
reinterpretAsBytes
public abstract ByteVector reinterpretAsBytes()このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyte
では、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。 これは、式reinterpretShape(species().withLanes(byte.class))
の簡易メソッドです。 これは、reinterpretAsInts()
など、同じベクトル内の大きいレーンにバイトを統合する様々なメソッドとは逆であると考えられます。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
ByteVector
- 関連項目:
reinterpretShape(VectorSpecies,int)
,IntVector.intoByteArray(byte[], int, ByteOrder)
,FloatVector.intoByteArray(byte[], int, ByteOrder)
,VectorSpecies.withLanes(Class)
-
reinterpretAsShorts
public abstract ShortVector reinterpretAsShorts()このベクトルを、同じシェイプおよび内容でレーン型のshort
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(short.class))
の簡易メソッドです。reinterpretAsBytes()
とは逆の場合があります。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
ShortVector
-
reinterpretAsInts
public abstract IntVector reinterpretAsInts()このベクトルを、同じシェイプおよび内容でレーン型のint
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(int.class))
の簡易メソッドです。reinterpretAsBytes()
とは逆の場合があります。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
IntVector
-
reinterpretAsLongs
public abstract LongVector reinterpretAsLongs()このベクトルを、同じシェイプおよび内容でレーン型のlong
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(long.class))
の簡易メソッドです。reinterpretAsBytes()
とは逆の場合があります。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
LongVector
-
reinterpretAsFloats
public abstract FloatVector reinterpretAsFloats()このベクトルを、同じシェイプおよび内容でレーン型のfloat
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(float.class))
の簡易メソッドです。reinterpretAsBytes()
とは逆の場合があります。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
FloatVector
-
reinterpretAsDoubles
public abstract DoubleVector reinterpretAsDoubles()このベクトルを、同じシェイプおよび内容でレーン型のdouble
のベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。 これは、式reinterpretShape(species().withLanes(double.class))
の簡易メソッドです。reinterpretAsBytes()
とは逆の場合があります。- 戻り値:
- 同じシェイプおよび情報コンテンツを持つ
DoubleVector
-
viewAsIntegralLanes
public abstract Vector<?> viewAsIntegralLanes()このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPE
またはVLENGTH
を変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPE
がすでに整数型である場合、同じベクトルが変更されずに返されます。 このメソッドは、この式の値を戻します:convert(conv,0)
。ここで、conv
はVectorOperators.Conversion.ofReinterpret(E.class,F.class)
で、F
はE
と同じサイズの非浮動小数点型です。- APIのノート:
- サブタイプは、戻り値の型をシャープにすることで、このメソッドで改善されます。
- 戻り値:
- 非浮動小数点として再解釈された、元のベクトル
- 関連項目:
VectorOperators.Conversion.ofReinterpret(Class,Class)
,convert(VectorOperators.Conversion,int)
-
viewAsFloatingLanes
public abstract Vector<?> viewAsFloatingLanes()このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。 これは、レーン値にキャストされたレーンワイズの再解釈です。 したがって、このメソッドはVSHAPE
またはVLENGTH
を変更せず、ベクトルのビット単位の内容は変更されません。 ベクトルETYPE
がすでに浮動小数点型である場合、同じベクトルが変更されずに返されます。 ベクトル要素のサイズが浮動小数点型のサイズと一致しない場合は、IllegalArgumentException
がスローされます。 このメソッドは、この式の値を戻します:convert(conv,0)
。conv
はVectorOperators.Conversion.ofReinterpret(E.class,F.class)
で、F
はE
と同じサイズの浮動小数点型です(存在する場合)。- APIのノート:
- サブタイプは、戻り値の型をシャープにすることで、このメソッドで改善されます。
- 戻り値:
- 浮動小数点として再解釈された、元のベクトル
- 例外:
UnsupportedOperationException
- このベクトルのレーンと同じサイズの浮動小数点型がない場合- 関連項目:
VectorOperators.Conversion.ofReinterpret(Class,Class)
,convert(VectorOperators.Conversion,int)
-
convert
public abstract <F> Vector<F> convert(VectorOperators.Conversion<E,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))
と同じです。- 型パラメータ:
F
- 種のboxed要素の型- パラメータ:
conv
- レーンワイズ適用に必要なスカラー変換part
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルからシェイプおよび要素型によって変換されたベクトル
- 例外:
ArrayIndexOutOfBoundsException
-part
がゼロでない場合、または拡張比率がM
でpart
が正でM
より小さい場合、または縮小率がM
でpart
が負で-M
より大きい場合- 関連項目:
VectorOperators.I2L
,VectorOperators.Conversion.ofCast(Class,Class)
,VectorSpecies.partLimit(VectorSpecies,boolean)
,viewAsFloatingLanes()
,viewAsIntegralLanes()
,convertShape(VectorOperators.Conversion,VectorSpecies,int)
,reinterpretShape(VectorSpecies,int)
-
-
convertShape
public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<E,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);
- 型パラメータ:
F
- 出力種のboxed要素型- パラメータ:
conv
- レーンワイズ適用に必要なスカラー変換rsp
- 目的の出力種part
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルから要素型によって変換されたベクトル
- 関連項目:
convert(VectorOperators.Conversion,int)
,castShape(VectorSpecies,int)
,reinterpretShape(VectorSpecies,int)
-
castShape
public abstract <F> Vector<F> castShape(VectorSpecies<F> rsp, int part)ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。 このメソッドは、この式の値を戻します:convertShape(conv,rsp,part)
。conv
はVectorOperators.Conversion.ofCast(E.class,F.class)
です。新旧の種のシェイプが異なる場合、これはshape-changing演算であり、特別な実装コストがかかる可能性があります。
- 型パラメータ:
F
- 出力種のboxed要素型- パラメータ:
rsp
- 目的の出力種part
- 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ- 戻り値:
- このベクトルから要素型によって変換されたベクトル
- 関連項目:
VectorOperators.Conversion.ofCast(Class,Class)
,convertShape(VectorOperators.Conversion,VectorSpecies,int)
-
check
このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。 効果は次の疑似コードのようになります :elementType == species().elementType() ? this : throw new ClassCastException()
。- 型パラメータ:
F
- 必要なレーン型のボックス化された要素型- パラメータ:
elementType
- 必要なレーン・タイプ- 戻り値:
- 同じベクトル
- 例外:
ClassCastException
- ベクトルの要素タイプが間違っている場合- 関連項目:
VectorSpecies.check(Class)
,VectorMask.check(Class)
,check(VectorSpecies)
,VectorShuffle.check(VectorSpecies)
-
check
public abstract <F> Vector<F> check(VectorSpecies<F> species)このベクトルが指定された種を持っているかどうかを判定し、このベクトルをそのまま返します。 効果は次の疑似コードのようになります :species == species() ? this : throw new ClassCastException()
。- 型パラメータ:
F
- 必要な種のボックス化された要素型- パラメータ:
species
- 必要な種- 戻り値:
- 同じベクトル
- 例外:
ClassCastException
- ベクトルの種が間違っている場合- 関連項目:
check(Class)
,VectorMask.check(VectorSpecies)
,VectorShuffle.check(VectorSpecies)
-
intoByteArray
public abstract void intoByteArray(byte[] a, int offset, ByteOrder bo)明示的なバイト順序を使用して、オフセットから始まるバイト配列にこのベクトルを格納します。バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。
このメソッドは、次のように
intoByteBuffer()
をコールするかのように動作します:var bb = ByteBuffer.wrap(a); var m = maskAll(true); intoByteBuffer(bb, offset, bo, m);
- パラメータ:
a
- バイト配列offset
- 配列へのオフセットbo
- 目的のバイト・オーダー- 例外:
IndexOutOfBoundsException
- ベクトル内のレーンN
のoffset+N*ESIZE < 0
またはoffset+(N+1)*ESIZE > a.length
の場合
-
intoByteArray
public abstract void intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<E> m)明示的なバイト順序とマスクを使用して、オフセットから始まるバイト配列にこのベクトルを格納します。バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。
このメソッドは、次のように
intoByteBuffer()
をコールするかのように動作します:var bb = ByteBuffer.wrap(a); intoByteBuffer(bb, offset, bo, m);
- パラメータ:
a
- バイト配列offset
- 配列へのオフセットbo
- 目的のバイト・オーダーm
- マスク制御レーンの選択- 例外:
IndexOutOfBoundsException
- マスクが設定されているベクトル内のレーンN
のoffset+N*ESIZE < 0
またはoffset+(N+1)*ESIZE > a.length
の場合
-
intoByteBuffer
public abstract void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)明示的なバイト順序を使用して、オフセットから始まるbyteバッファにこのベクトルを格納します。バイトは、指定されたバイト順序に従ってプリミティブ・レーン要素から抽出されます。 レーンは、その「メモリーの順序」に従って格納されます。
このメソッドは、次のように
intoByteBuffer()
をコールするかのように動作します:var m = maskAll(true); intoByteBuffer(bb, offset, bo, m);
- パラメータ:
bb
- byteバッファoffset
- 配列へのオフセットbo
- 目的のバイト・オーダー- 例外:
IndexOutOfBoundsException
- ベクトル内のレーンN
のoffset+N*ESIZE < 0
またはoffset+(N+1)*ESIZE > bb.limit()
の場合ReadOnlyBufferException
- byteバッファが読取り専用かどうか
-
intoByteBuffer
public abstract void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<E> 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);
- 実装上のノート:
- このメソッドはレーン値のバイトを並べ替える必要がないため、指定されたバイト順序が「プラットフォームのネイティブ順序」と同じ場合は、この演算がより効率的になる可能性があります。
ETYPE
がbyte
の特殊なケースでは、byte order引数は無視されます。 - パラメータ:
bb
- byteバッファoffset
- 配列へのオフセットbo
- 目的のバイト・オーダーm
- マスク制御レーンの選択- 例外:
IndexOutOfBoundsException
- マスクが設定されているベクトル内のレーンN
のoffset+N*ESIZE < 0
またはoffset+(N+1)*ESIZE > bb.limit()
の場合ReadOnlyBufferException
- byteバッファが読取り専用かどうか
-
toArray
public abstract Object toArray()すべてのレーン値を含むパックされた配列を返します。 配列の長さはベクトルの長さと同じです。 配列の要素タイプは、ベクトルの要素タイプと同じです。 配列要素はレーン順に格納されます。 要素型を指定するVector
のサブタイプでこのメソッドをオーバーライドすると、正確に型指定された配列結果が得られます。- APIのノート:
- 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
- 戻り値:
- このベクトルのレーン値を含む、正確に型指定された配列
- 関連項目:
ByteVector.toArray()
,IntVector.toArray()
,DoubleVector.toArray()
-
toIntArray
public abstract int[] toIntArray()int
型に変換された、すべてのレーン値を含むint[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプがfloat
またはdouble
の場合、この演算は失敗する可能性があります。 ベクトル・レーン値がint
として表現できない場合は、例外がスローされます。- APIのノート:
- 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
- 戻り値:
- このベクトルのレーン値を含む
int[]
配列 - 例外:
UnsupportedOperationException
- レーン値をint
配列要素として表現できない場合- 関連項目:
toArray()
,toLongArray()
,toDoubleArray()
,IntVector.toArray()
-
toLongArray
public abstract long[] toLongArray()long
型に変換された、すべてのレーン値を含むlong[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプがfloat
またはdouble
の場合、この演算は失敗する可能性があります。 ベクトル・レーン値がlong
として表現できない場合は、例外がスローされます。- APIのノート:
- 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
- 戻り値:
- このベクトルのレーン値を含む
long[]
配列 - 例外:
UnsupportedOperationException
- レーン値をlong
配列要素として表現できない場合- 関連項目:
toArray()
,toIntArray()
,toDoubleArray()
,LongVector.toArray()
-
toDoubleArray
public abstract double[] toDoubleArray()double
型に変換された、すべてのレーン値を含むdouble[]
配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 ベクトル要素タイプがlong
の場合、この演算によって精度が失われる可能性があります。- APIのノート:
- 既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、
strongly typed access
をお薦めします。 - 戻り値:
- このベクトルのレーン値を含む
double[]
配列。表現可能なdouble
値に丸められる可能性がある - 関連項目:
toArray()
,toIntArray()
,toLongArray()
,DoubleVector.toArray()
-
toString
public abstract String toString()このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"
形式のこのベクトルの文字列表現を返します。 この文字列は、this.toArray()
によって返される配列に応じて、Arrays.toString()
へのコールによって生成されるかのように生成されます。 -
equals
public abstract boolean equals(Object obj)このベクトルが他のオブジェクトと同一かどうかを示します。 2つのベクトルは、同じ種と同じレーン値を同じ順序で持つ場合にのみ同一です。レーン値の比較は、両方のベクトルの
toArray()
によって返される配列に応じて、Arrays.equals()
をコールした場合と同様に生成されます。- オーバーライド:
equals
、クラス:Object
- パラメータ:
obj
- 比較対象の参照オブジェクト。- 戻り値:
- このベクトルがほかのオブジェクトと同一かどうか
- 関連項目:
eq(jdk.incubator.vector.Vector<E>)
-
hashCode
public abstract int hashCode()レーン値とベクトル種に基づいて、ベクトルのハッシュ・コード値を返します。- オーバーライド:
hashCode
、クラス:Object
- 戻り値:
- このベクトルのハッシュ・コード値
- 関連項目:
Object.equals(java.lang.Object)
,System.identityHashCode(java.lang.Object)
-