クラスVector<E>

java.lang.Object
jdk.incubator.vector.Vector<E>
型パラメータ:
E - ETYPEのボックス版、ベクトルの要素型
直系の既知のサブクラス:
ByteVector, DoubleVector, FloatVector, IntVector, LongVector, ShortVector
public abstract class Vector<E> extends Object
A 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になります。 したがって、このようなレーンワイズ操作は基本定義でlength-invariantです。

長さ不変性の原則は別の基本原則と結合され、ほとんどの長さ不変なレーンワイズ操作もshape-invariantです。これは、レーンワイズ操作の入力と出力には共通の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つの隣接するベクトル・レーンがある場合、1つのレーンが近傍よりも何らかの形で有意義なアルゴリズムを見つけることは比較的まれであり、このような場合でも、どのネイバーがより重要であるかを知る一般的な方法はありません。

用語をまとめると、ベクトルの情報構造は、内部的に空間的に("low"から"high"または"right"から"left"のいずれか)で順序付けされたビット文字列のレーン("first", "next", "前", "後で", "last", etc.)の一時的なシーケンスとして表示されます。 レーンのプリミティブ値は、通常の方法でこれらのビット文字列からデコードされます。 ほとんどのベクトル演算子は、ほとんどのJavaスカラー演算子と同様に、プリミティブ値をアトミック値として扱いますが、一部の演算子では内部ビット文字列構造が明らかになります。

ベクトルがメモリーからロードされるか、メモリーに格納される場合、ベクトル・レーンの順序は、メモリー・コンテナの固有の順序を持つ「常に一貫性がある」です。 これは、バイト・オーダーの詳細のために個々のレーン要素が"バイト・スワップ"の対象であるかどうかにかかわらず当てはまります。 したがって、ベクトルのスカラー・レーン要素は"スワップされたバイト"である可能性がありますが、レーンの順序変更を実行する明示的なメソッド・コールを除き、レーン自体は順序変更されません。

ベクトル・レーン値が同じタイプのJava変数に格納されている場合、ベクトル・ハードウェアの実装でこのようなスワッピングが必要な場合にのみバイト・スワッピングが実行されます。 したがって、無条件で不可視です。

このAPIは、有用なフィクションとして、ベクトル・レーンのバイトが「リトル・エンディアン順序」の大きいレーンのスカラーに構成されているという一貫した状況を表します。 つまり、ベクトルをJavaバイト配列に格納すると、ネイティブ・メモリーの順序や、ベクトル・ユニット・レジスタ内のバイト順序(もしあれば)に関係なく、すべてのプラットフォームでベクトル・レーン値の連続バイトがリトル・エンディアン順で表示されます。

この仮想リトル・エンディアン順序は、ベクトル・ビットを変更せずにレーン境界が破棄および再描画されるような方法で「再解釈キャスト」を適用した場合にも表示されます。 このような演算では、隣接する2つのレーンが単一の新しいレーン(またはその逆)にバイトを提供し、2つのレーンの順序によって単一レーン内のバイトの算術順序が決定されます。 この場合、リトル・エンディアン規則によって移植可能な結果が提供されるため、すべてのプラットフォームで、以前のレーンでは下位(右方向)ビットがコントリビュートされ、後続のレーンでは上位(左向き)ビットがコントリビュートされる傾向があります。 ByteVectorとその他の非バイト・ベクトル間の「再解釈キャスト」では、移植可能なセマンティクスを明確にするためにこの規則が使用されます。

レーンの順序をレーンごとのバイト順序に関連付けるリトル・エンディアンのフィクションは、同等のビッグ・エンディアンのフィクションよりも若干推奨されます。これは、一部の関連する式(特にレーン構造の変更後にバイト数を再番号付けする式)がはるかに単純であるためです。 もっとも古いバイトは、リトル・エンディアン規則が使用されている場合にかぎり、レーン構造のすべての変更において不変的に早いバイトです。 この根本的な原因は、スカラー内のバイトに、最も重要度の低い(右端)から最も重要度の高い(左端)までの番号が付けられ、その逆も同様ではないことです。 符号ビットの番号がゼロ(一部のコンピュータと同様)である場合、このAPIはビッグ・エンディアンのフィクションに到達し、ベクトル・バイトの統一アドレスを作成します。

メモリー操作

前述のように、ベクトルはメモリーからロードして戻すことができます。 オプションのマスクを使用すると、読み取りまたは書き込みの対象となる個々のメモリー・ロケーションを制御できます。 ベクトルのシェイプによって、ベクトルが占有するメモリー量が決まります。 実装には通常、マスキングがない場合、レーンはスカラー型の配列内の単一スカラー値の稠密な(gap-free)系列と同じように、バック・トゥ・バック値の稠密なシーケンスとしてメモリーに格納されるというプロパティがあります。 このような場合、メモリーの順序はレーンの順序に正確に対応します。 最初のベクトル・レーン値は、メモリー内の最初の位置を占有し、ベクトルの長さまで続きます。 さらに、ストアド・ベクトル・レーンのメモリー順序は、Java配列またはMemorySegmentでの索引値の増加に対応しています。

ベクトルを保持する配列またはセグメント内で、ストレージされたベクトル値を単一のプリミティブ値として読み書きできるように、レーン・ストレージのバイト順序が選択され、ベクトル内のレーンワイズ値と同じ値が生成されます。 このことは、ベクトルの内側のレーンの値がリトル・エンディアン順に格納されるという便利なフィクションとは無関係です。

たとえば、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には、このような「サイズ変更」ベクトル演算の設計に対する体系的なアプローチがあります。

基本原則として、一般的には明確にマークされていないかぎり、レーンワイズの操作はlength-invariantです。 長さ不変とは、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では、数学的順列および他の多くのデータ移動パターンをエンコードできます。
  • 入力ベクトルから最大VLENGTHレーンを選択し、レーン順にアセンブルするcompress(VectorMask)およびexpand(VectorMask)メソッド。 レーンの選択はVectorMaskで制御され、レーン要素のマッピングは、レーンの順序で圧縮または拡張、発信元レーンと着信先レーンで制御されます。

ベクトル演算の中には、レーンワイズではなく、レーン境界を越えてデータを移動するものがあります。 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フィールドまたは配列要素に格納すると、パフォーマンスが低下する可能性があります。

  • メソッドのサマリー

    修飾子と型
    メソッド
    説明
    abstract Vector<E>
    abs()
    このベクトルの絶対値を返します。
    abstract Vector<E>
    add(Vector<E> v)
    このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    add(Vector<E> v, VectorMask<E> m)
    マスクの制御下にあるレーンを選択して、このベクトルを2番目の入力ベクトルに追加します。
    abstract Vector<E>
    addIndex(int scale)
    指定された定数でスケーリングされた、このベクトルのレーンを対応するレーン番号に追加します。
    abstract int
    bitSize()
    このベクトルの合計サイズをビット単位で返します。
    abstract Vector<E>
    blend(long e, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にあるスカラー値で置き換えます。
    abstract Vector<E>
    blend(Vector<E> v, VectorMask<E> m)
    このベクトルの選択されたレーンを、マスクの制御下にある2番目の入力ベクトルの対応するレーンに置き換えます。
    abstract Vector<E>
    broadcast(long e)
    すべてのレーン要素がプリミティブ値eに設定されている、この種と同じ種のベクトルを返します。
    abstract int
    byteSize()
    このベクトルの合計サイズ(バイト単位)を返します。
    abstract <F> Vector<F>
    castShape(VectorSpecies<F> rsp, int part)
    ベクトルをあるレーン・タイプから別のレーン・タイプに変換する便利なメソッドで、レーン・サイズが変更されたときに必要に応じてシェイプを変更します。
    abstract <F> Vector<F>
    check(Class<F> elementType)
    このベクトルが指定された要素型を持つことを確認し、このベクトルを変更せずに返します。
    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 Vector<E>
    compress(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と呼びます)に変換します。
    abstract Vector<E>
    div(Vector<E> v)
    このベクトルを2番目の入力ベクトルで除算します。
    abstract Vector<E>
    div(Vector<E> v, VectorMask<E> m)
    このベクトルをマスクの制御下にある2番目の入力ベクトルで除算します。
    abstract int
    elementSize()
    このベクトルの各レーンのサイズをビット単位で返します。
    abstract Class<E>
    elementType()
    このベクトルのプリミティブ「要素型」 (ETYPE)を返します。
    abstract VectorMask<E>
    eq(Vector<E> v)
    このベクトルが別の入力ベクトルと等しいかどうかを判定します。
    abstract boolean
    equals(Object obj)
    このベクトルが他のオブジェクトと同一かどうかを示します。
    abstract Vector<E>
    expand(VectorMask<E> m)
    このベクトルのレーン要素を特定のマスクの制御下で展開します。
    protected final Object
    getPayload()
     
    abstract int
    hashCode()
    ベクトルのハッシュ・コード値を返します。
    abstract void
    intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)
    このベクトルを、明示的なバイト順序を使用してオフセットから始まる「メモリー・セグメント」に格納します。
    abstract void
    intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<E> m)
    このベクトルを、明示的なバイト順序とマスクを使用してオフセットから始まる「メモリー・セグメント」に格納します。
    abstract Vector<E>
    lanewise(VectorOperators.Binary op, long e)
    このベクトルのレーン値をブロードキャスト・スカラーの値と結合します。
    abstract Vector<E>
    lanewise(VectorOperators.Binary op, long e, VectorMask<E> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract Vector<E>
    lanewise(VectorOperators.Binary op, Vector<E> v)
    このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。
    abstract Vector<E>
    lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)
    このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。
    abstract Vector<E>
    lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2)
    このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。
    abstract Vector<E>
    lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> m)
    このベクトルの対応するレーン値を2番目と3番目の入力ベクトルのレーンと組み合わせ、マスクによって制御されるレーン要素を選択します。
    abstract Vector<E>
    lanewise(VectorOperators.Unary op)
    このベクトルのレーン値を操作します。
    abstract Vector<E>
    lanewise(VectorOperators.Unary op, VectorMask<E> m)
    マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。
    abstract int
    length()
    レーン数または「ベクトル長さ」 (VLENGTH)を返します。
    abstract VectorMask<E>
    lt(Vector<E> v)
    このベクトルが別の入力ベクトルより小さいかどうかを判定します。
    abstract VectorMask<E>
    maskAll(boolean bit)
    このベクトルと同じ種のマスクを返します。各レーンは、すべてのレーンにブロードキャストされる指定された単一のbooleanに従って設定または設定解除されます。
    abstract Vector<E>
    max(Vector<E> v)
    このベクトルと2番目の入力ベクトルの大きい方を計算します。
    abstract Vector<E>
    min(Vector<E> v)
    このベクトルと2番目の入力ベクトルの小さい方を計算します。
    abstract Vector<E>
    mul(Vector<E> v)
    このベクトルに2番目の入力ベクトルを掛けます。
    abstract Vector<E>
    mul(Vector<E> v, VectorMask<E> m)
    マスクの制御下にある2番目の入力ベクトルでこのベクトルを乗算します。
    abstract Vector<E>
    neg()
    このベクトルを否定します。
    abstract Vector<E>
    rearrange(VectorShuffle<E> s)
    特定のシャッフルの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract Vector<E>
    rearrange(VectorShuffle<E> s, Vector<E> v)
    特定のシャッフルの制御下にあるレーンを選択し、シャッフル内の通常のインデックスと例外的なインデックスの両方を使用して、2つのベクトルのレーン要素の位置を変更します。
    abstract Vector<E>
    rearrange(VectorShuffle<E> s, VectorMask<E> m)
    特定のシャッフルとマスクの制御下にあるレーンを選択して、このベクトルのレーン要素を再配置します。
    abstract long
    reduceLanesToLong(VectorOperators.Associative op)
    このベクトルのすべてのレーンから累積された値を返します。
    abstract long
    reduceLanesToLong(VectorOperators.Associative op, VectorMask<E> m)
    マスクによって制御される、このベクトルの選択されたレーンから累積された値を返します。
    abstract ByteVector
    reinterpretAsBytes()
    このベクトルを同じシェイプと内容のベクトルとして表示しますが、レーン型のbyteでは、バイトはリトル・エンディアンの順序に従ってレーンから抽出されます。
    abstract DoubleVector
    reinterpretAsDoubles()
    このベクトルを、同じシェイプおよび内容でレーン型のdoubleのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract FloatVector
    reinterpretAsFloats()
    このベクトルを、同じシェイプおよび内容でレーン型のfloatのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract IntVector
    reinterpretAsInts()
    このベクトルを、同じシェイプおよび内容でレーン型のintのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract LongVector
    reinterpretAsLongs()
    このベクトルを、同じシェイプおよび内容でレーン型のlongのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract ShortVector
    reinterpretAsShorts()
    このベクトルを、同じシェイプおよび内容でレーン型のshortのベクトルとして再解釈します。レーンはリトル・エンディアンの順序に従って連続したバイトから組み立てられます。
    abstract <F> Vector<F>
    reinterpretShape(VectorSpecies<F> species, int part)
    値の変換を実行せずに、このベクトルを要素型Fの指定された種のベクトルに変換し、このベクトルのバイトを再解釈します。
    abstract Vector<E>
    selectFrom(Vector<E> v)
    このベクトルのレーンに格納されている索引値を使用して、2番目のベクトルvに格納されている値をアセンブルします。
    abstract Vector<E>
    selectFrom(Vector<E> v1, Vector<E> v2)
    このベクトルのレーンに格納されている値を使用して、2番目のベクトルv1および3番目のベクトルv2に格納されている値を組み立てます。
    abstract Vector<E>
    selectFrom(Vector<E> v, VectorMask<E> m)
    このベクトルのレーンに格納されているインデックス値を使用して、マスクの制御下で2番目のベクトルに格納されている値を組み立てます。
    abstract VectorShape
    shape()
    このベクトルのシェイプを返します。
    abstract Vector<E>
    slice(int origin)
    現在のベクトル内の指定されたoriginレーンから始まる隣接レーンのセグメントをスライスします。
    abstract Vector<E>
    slice(int origin, Vector<E> v1)
    現在のベクトル内の指定されたoriginレーンから始まり、すぐ後のベクトルに(必要に応じて)を継続して、隣接するレーンのセグメントをスライスします。
    abstract Vector<E>
    slice(int origin, Vector<E> v1, VectorMask<E> m)
    マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定されたoriginレーンから開始し、(必要に応じて)を直後のベクトルに継続します。
    abstract VectorSpecies<E>
    species()
    このベクトルの種を返します。
    abstract Vector<E>
    sub(Vector<E> v)
    このベクトルから2番目の入力ベクトルを減算します。
    abstract Vector<E>
    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[]
    toDoubleArray()
    double型に変換された、すべてのレーン値を含むdouble[]配列を返します。
    abstract int[]
    toIntArray()
    int型に変換された、すべてのレーン値を含むint[]配列を返します。
    abstract long[]
    toLongArray()
    long型に変換された、すべてのレーン値を含むlong[]配列を返します。
    abstract VectorShuffle<E>
    toShuffle()
    このベクトルをシャッフルに変換し、レーン値をintに変換して、ソース索引として認識します。
    abstract String
    toString()
    このベクトルのレーン値をレーン順に報告する、"[0,1,2...]"形式のこのベクトルの文字列表現を返します。
    abstract Vector<E>
    unslice(int origin)
    slice()を逆にして、ゼロ・レーン値の"background"入力内に現在のベクトルをスライスとして挿入します。
    abstract Vector<E>
    unslice(int origin, Vector<E> w, int part)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract Vector<E>
    unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
    slice()を逆にして、現在のベクトルを別の"background"入力ベクトル内のスライスとして(マスクの制御下)に挿入します。これは、後続の仮想slice()演算に対する一方または他方の入力とみなされます。
    abstract Vector<?>
    viewAsFloatingLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型です。
    abstract Vector<?>
    viewAsIntegralLanes()
    このベクトルを同じシェイプ、長さ、内容のベクトルとして表示しますが、レーン型は浮動小数点型ではありません。

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

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

  • メソッドの詳細

    • species

      public abstract VectorSpecies<E> species()
      このベクトルの種を返します。
      戻り値:
      このベクトルの種

    • elementType

      public abstract Class<E> 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 - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public abstract Vector<E> lanewise(VectorOperators.Unary op, VectorMask<E> m)
      マスクによって制御されるレーン要素の選択を使用して、このベクトルのレーン値を操作します。 これは、選択した演算を各レーンに適用するレーンワイズ単項演算です。
      APIのノート:
      サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
      パラメータ:
      op - レーン値の処理に使用される演算
      m - マスク制御レーンの選択
      戻り値:
      入力ベクトルにレーンワイズ演算を適用した結果
      スロー:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public abstract Vector<E> lanewise(VectorOperators.Binary op, Vector<E> v)
      このベクトルの対応するレーン値を2番目の入力ベクトルのレーン値と結合します。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。
      APIのノート:
      サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
      パラメータ:
      op - レーン値を結合するために使用される演算
      v - 入力ベクトル
      戻り値:
      2つの入力ベクトルにレーンワイズ演算を適用した結果
      スロー:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • lanewise

      public abstract Vector<E> lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> m)
      このベクトルの対応するレーン値と2番目の入力ベクトルのレーン値を、マスクによって制御されるレーン要素の選択と組み合わせます。 これは、選択した演算を各レーンに適用するレーンワイズ二項演算です。
      APIのノート:
      サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
      パラメータ:
      op - レーン値を結合するために使用される演算
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      2つの入力ベクトルにレーンワイズ演算を適用した結果
      スロー:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • 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値をベクトル演算の右側のオペランド型で表現できない場合
      関連項目:

    • 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値をベクトル演算の右側のオペランド型で表現できない場合
      関連項目:

    • lanewise

      public abstract Vector<E> lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2)
      このベクトルの対応するレーン値を、2番目と3番目の入力ベクトルのレーンと結合します。 これは、選択した演算を各レーンに適用するレーンワイズの三項演算です。
      APIのノート:
      サブタイプは、メソッドの戻り値の型をシャープにすることで、このメソッドで改善されます。
      パラメータ:
      op - レーン値を結合するために使用される演算
      v1 - 2番目の入力ベクトル
      v2 - 3番目の入力ベクトル
      戻り値:
      3つの入力ベクトルに演算レーンワイズを適用した結果
      スロー:
      UnsupportedOperationException - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • 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 - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • add

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

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

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

    • add

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

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

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

    • sub

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

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

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

    • sub

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

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

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

    • mul

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

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

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

    • mul

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

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

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

    • div

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

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

      APIのノート:
      基本となるスカラー演算子がゼロ除算をサポートしていないが、ゼロ除数で表示される場合は、ArithmeticExceptionがスローされます。
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルを2番目の入力ベクトルで割った結果
      スロー:
      ArithmeticException - vのレーンがゼロで、ETYPEがfloatまたはdoubleでない場合。
      関連項目:

    • div

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

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

      APIのノート:
      基本となるスカラー演算子がゼロ除算をサポートしていないが、ゼロ除数で表示される場合は、ArithmeticExceptionがスローされます。
      パラメータ:
      v - 2番目の入力ベクトル
      m - マスク制御レーンの選択
      戻り値:
      このベクトルを2番目の入力ベクトルで割った結果
      スロー:
      ArithmeticException - vでmによって選択されたレーンがゼロで、ETYPEがfloatまたはdoubleでない場合。
      関連項目:

    • neg

      public abstract Vector<E> neg()
      このベクトルを否定します。 これは、プリミティブ否定演算(-x)を各入力レーンに適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( NEG)とも同じです。
      APIのノート:
      このメソッドにはマスクされたバリアントはありませんが、対応するマスクされた演算は「レーンに関するメソッド」から取得できます。
      戻り値:
      このベクトルの否定
      関連項目:

    • abs

      public abstract Vector<E> abs()
      このベクトルの絶対値を返します。 これは、各入力レーンにメソッドMath.absを適用するレーンワイズ単項演算です。 このメソッドは、式lanewise( ABS)とも同じです。
      APIのノート:
      このメソッドにはマスクされたバリアントはありませんが、対応するマスクされた演算は「レーンに関するメソッド」から取得できます。
      戻り値:
      このベクトルの絶対値
      関連項目:

    • min

      public abstract Vector<E> min(Vector<E> v)
      このベクトルと2番目の入力ベクトルの小さい方を計算します。 これは、演算Math.min()を対応するレーン値の各ペアに適用するレーンワイズ二項演算です。 このメソッドは、式lanewise( MIN, v)とも同じです。
      APIのノート:
      これは、add()のようなフル・サービス名前付き演算ではありません。 この演算のマスクされたバージョンは直接使用できませんが、マスクされたバージョンのlanewiseを介して取得できます。 サブクラスは、このメソッドの追加のスカラー・ブロードキャスト・オーバーロードを定義します。
      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルと2番目の入力ベクトルのレーン最小値
      関連項目:

    • max

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

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

      パラメータ:
      v - 2番目の入力ベクトル
      戻り値:
      このベクトルと2番目の入力ベクトルのレーン方向の最大値
      関連項目:

    • 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

      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 - このベクトルがリクエストされた演算をサポートしていない場合
      関連項目:

    • test

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

    • test

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

    • eq

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

    • lt

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

    • compare

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

    • 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

      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で表現できない場合
      関連項目:

    • 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で表現できない場合
      関連項目:

    • blend

      public abstract Vector<E> blend(Vector<E> v, VectorMask<E> 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);
      パラメータ:
      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

      public abstract Vector<E> 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);

      パラメータ:
      scale - 各レーン索引Nで乗算する数(通常は1)
      戻り値:
      scaleによってスケーリングされた、各レーン要素を対応するレーン索引Nで増分した結果
      スロー:
      IllegalArgumentException - 間隔[0..VLENGTH*scale]の値がETYPEで表現できない場合

    • slice

      public abstract Vector<E> slice(int origin, Vector<E> 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を返します。

      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)。

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

    • slice

      public abstract Vector<E> slice(int origin, Vector<E> v1, VectorMask<E> m)
      マスクの制御下にある隣接レーンのセグメントをスライスします。現在のベクトル内の指定された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

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

    • unslice

      public abstract Vector<E> unslice(int origin, Vector<E> 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を返します。

      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がゼロまたはいずれでもない場合
      関連項目:

    • unslice

      public abstract Vector<E> unslice(int origin, Vector<E> w, int part, VectorMask<E> m)
      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

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

    • rearrange

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

    • rearrange

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

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

      
 Vector<E> r = this.rearrange(s);
 return broadcast(0).blend(r, m);

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

    • rearrange

      public abstract Vector<E> rearrange(VectorShuffle<E> s, Vector<E> 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());

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

    • compress

      public abstract Vector<E> compress(VectorMask<E> m)
      特定のマスクのコントロールの下にあるレーンを選択する、このベクトルのレーン要素を圧縮します。 これは、指定されたマスクによって選択されたこのベクトルのレーン要素を圧縮するクロス・レーン演算です。 マスクの各レーンNについて、レーンNのマスクが設定されている場合、入力ベクトルのレーンNの要素が選択され、レーン0から開始して連続して出力ベクトルに格納されます。 出力ベクトルの残りのレーンがある場合は、すべてゼロに設定されます。
      パラメータ:
      m - 圧縮を制御するマスク
      戻り値:
      このベクトルの圧縮レーン要素
      導入されたバージョン:
      19

    • expand

      public abstract Vector<E> expand(VectorMask<E> m)
      このベクトルのレーン要素を特定のマスクの制御下で展開します。 これは、このベクトルの連続するレーン要素を、指定されたマスクによって選択された出力ベクトルのレーンに拡張するクロス・レーン演算です。 マスクの各レーンNについて、レーンNのマスクが設定されている場合、レーン0から始まる入力ベクトルの次の連続した要素が選択され、レーンNの出力ベクトルに格納されます。 出力ベクトルの残りのレーン(ある場合)はすべてゼロに設定されます。
      パラメータ:
      m - 圧縮を制御するマスク
      戻り値:
      このベクトルの展開されたレーン要素
      導入されたバージョン:
      19

    • selectFrom

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

    • selectFrom

      public abstract Vector<E> selectFrom(Vector<E> v1, Vector<E> v2)
      このベクトルのレーンに格納されている値を使用して、2番目のベクトルv1および3番目のベクトルv2に格納されている値を組み立てます。 したがって、2番目と3番目のベクトルは、このベクトルの索引によって要素が選択される表として機能します。 これは、このベクトルの制御下で、引数ベクトルのレーン要素を再配置するクロス・レーン操作です。 このベクトルの各レーンNについて、およびこのベクトルの各レーン値I=wrapIndex(this.lane(N)について、I < VLENGTHの場合、出力レーンNはレーンIの2番目のベクトルから値を取得します。 それ以外の場合、出力レーンNは、レーンI - VLENGTHの3番目のベクトルから値を取得します。 ここで、VLENGTHはthis.length()の結果であり、整数値の場合、wrapIndexはMath.floorMod(E, 2 * VLENGTH)の結果を計算します。ここで、Eはラップされる索引です。 VLENGTHが2の累乗であるかぎり、結果もE & (2 * VLENGTH - 1)と等しくなります。 浮動小数点値の場合、wrapIndexはMath.floorMod(convert(E), 2 * VLENGTH)を計算します。ここで、convertは浮動小数点値を同じ数の表現ビットを持つ整数値に変換 - double値をlong値((long)doubleVal)に変換する場合と同様、float値をint値((int)floatVal)に変換します。 このようにして、結果には、引数ベクトルv1およびv2に格納されている値のみが含まれますが、thisの索引値に依存する順序で表示されます。 整数値の結果は式と同じです 
      v1.rearrange(
this.lanewise(VectorOperators.AND, 2 * VLENGTH - 1).toShuffle(),
v2)
      VLENGTHが2の累乗の場合。 レーンワイズAND操作の結果、要素が[0, 2 * VLENGTH - 1])の範囲にあるベクトルになります。 シャッフル変換では、索引が[-VLENGTH, VLENGTH - 1])の範囲にある部分的にラップされたシャッフルが発生します。このシャッフル変換では、例外索引を使用して3番目のベクトルの要素を選択します。
      パラメータ:
      v1 - 最初の入力ベクトル
      v2 - 2番目の入力ベクトル
      戻り値:
      v1およびv2のレーン要素の再配置
      関連項目:

    • selectFrom

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

    • broadcast

      public abstract Vector<E> 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値は常に受け入れられます。

      APIのノート:
      サブタイプは、メソッドの戻り値の型とスカラー・パラメータeの型をシャープにすることで、このメソッドで改善されます。
      パラメータ:
      e - ブロードキャストする値
      戻り値:
      すべてのレーン要素がプリミティブ値eに設定されているベクトル
      スロー:
      IllegalArgumentException - 指定されたlong値をベクトルETYPEで表現できない場合
      関連項目:

    • maskAll

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

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

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

    • 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);

      戻り値:
      このベクトルのシャッフル表現
      関連項目:

    • reinterpretShape

      public abstract <F> Vector<F> reinterpretShape(VectorSpecies<F> species, int part)
      値の変換を実行せずに、このベクトルを要素型Fの指定された種のベクトルに変換し、このベクトルのバイトを再解釈します。

      選択した種によっては、この演算によって「拡大または縮小」の論理結果が生成される場合があります。その場合は、ゼロ以外のpart番号を使用して、論理結果の選択および物理出力ベクトルへのリングをさらに制御できます。

      このベクトルのベースとなるビットは変更なしで結果のベクトルにコピーされますが、コピー前に、このベクトルのビット・サイズが目的のベクトルのビット・サイズより大きい場合は切り捨てられ、このベクトルのビット・サイズが目的のベクトルのビット・サイズより小さい場合はゼロのビットで埋められます。

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

      このメソッドは、このベクトルがリトル・エンディアン・バイト順序を使用してバイト配列に格納される場合と同様に動作し、同じ順序で同じバイト配列から目的のベクトルがロードされます。

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

      
 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);
 MemorySegment ms = MemorySegment.ofArray(new byte[Math.max(domSize, ranSize)]);
 if (domSize > ranSize) {  // expansion
     this.intoMemorySegment(ms, 0, ByteOrder.native());
     int origin = part * ranSize;
     return species.fromMemorySegment(ms, origin, ByteOrder.native());
 } else {  // contraction or size-invariant
     int origin = (-part) * domSize;
     this.intoMemorySegment(ms, origin, ByteOrder.native());
     return species.fromMemorySegment(ms, 0, ByteOrder.native());
 }

      APIのノート:
      このメソッドは、問題のベクトルがメモリーにロードまたは格納されたかのように定義されますが、メモリー・セマンティクスは実際の実装とほとんど関係がないか、まったく関係がありません。 リトル・エンディアン順序付けへのアピールは、レーン構造化ベクトルとバイト構造化ベクトル間のマッピングに関連する多数の詳細ルールになる可能性のあるものの短縮形です。
      型パラメータ:
      F - 種のboxed要素の型
      パラメータ:
      species - 目的のベクトル種
      part - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルからシェイプおよび要素型によって変換されたベクトル
      関連項目:

    • reinterpretAsBytes

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

    • 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のノート:
      サブタイプは、戻り値の型をシャープにすることで、このメソッドで改善されます。
      戻り値:
      非浮動小数点として再解釈された、元のベクトル
      関連項目:

    • viewAsFloatingLanes

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

    • 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%を出力ベクトルの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))と同じです。

      型パラメータ:
      F - 種のboxed要素の型
      パラメータ:
      conv - レーンワイズ適用に必要なスカラー変換
      part - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルからシェイプおよび要素型によって変換されたベクトル
      スロー:
      ArrayIndexOutOfBoundsException - partがゼロでない場合、または拡張比率がMでpartが正でMより小さい場合、または縮小率がMでpartが負で-Mより大きい場合
      関連項目:

    • 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 - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルから要素型によって変換されたベクトル
      関連項目:

    • 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 - 結果の「パーツ番号」。拡張も縮小もしない場合はゼロ
      戻り値:
      このベクトルから要素型によって変換されたベクトル
      関連項目:

    • check

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

    • check

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

    • intoMemorySegment

      public abstract void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)
      このベクトルを、明示的なバイト順序を使用してオフセットから始まる「メモリー・セグメント」に格納します。

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

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

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

      パラメータ:
      ms - メモリー・セグメント
      offset - メモリー・セグメントへのオフセット
      bo - 目的のバイト・オーダー
      スロー:
      IndexOutOfBoundsException - ベクトル内のレーンNのoffset+N*ESIZE < 0またはoffset+(N+1)*ESIZE > ms.byteSize()の場合
      UnsupportedOperationException - メモリー・セグメントが読み取り専用の場合
      IllegalArgumentException - メモリー・セグメントがbyte[]配列によって支えられていないヒープ・セグメントである場合。
      IllegalStateException - メモリー・セグメント・セッションが有効でない場合、またはセッションを所有しているスレッド以外のスレッドからアクセスが発生した場合。
      導入されたバージョン:
      19

    • intoMemorySegment

      public abstract void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<E> 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);
     }
 }

      実装上のノート:
      このメソッドはレーン値のバイトを並べ替える必要がないため、指定されたバイト順序が「プラットフォームのネイティブ順序」と同じ場合は、この演算がより効率的になる可能性があります。 ETYPEがbyteの特殊なケースでは、byte order引数は無視されます。
      パラメータ:
      ms - メモリー・セグメント
      offset - メモリー・セグメントへのオフセット
      bo - 目的のバイト・オーダー
      m - マスク制御レーンの選択
      スロー:
      IndexOutOfBoundsException - マスクが設定されているベクトル内のレーンNのoffset+N*ESIZE < 0またはoffset+(N+1)*ESIZE > ms.byteSize()の場合
      UnsupportedOperationException - メモリー・セグメントが読み取り専用の場合
      IllegalArgumentException - メモリー・セグメントがbyte[]配列によって支えられていないヒープ・セグメントである場合。
      IllegalStateException - メモリー・セグメント・セッションが有効でない場合、またはセッションを所有しているスレッド以外のスレッドからアクセスが発生した場合。
      導入されたバージョン:
      19

    • toArray

      public abstract Object toArray()
      すべてのレーン値を含むパックされた配列を返します。 配列の長さはベクトルの長さと同じです。 配列の要素タイプは、ベクトルの要素タイプと同じです。 配列要素はレーン順に格納されます。 要素型を指定するVectorのサブタイプでこのメソッドをオーバーライドすると、正確に型指定された配列結果が得られます。
      APIのノート:
      既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
      戻り値:
      このベクトルのレーン値を含む、正確に型指定された配列
      関連項目:

    • toIntArray

      public abstract int[] toIntArray()
      int型に変換された、すべてのレーン値を含むint[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプが floatまたはdoubleの場合、この演算は失敗する可能性があります。 ベクトル・レーン値がintとして表現できない場合は、例外がスローされます。
      APIのノート:
      既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
      戻り値:
      このベクトルのレーン値を含むint[]配列
      スロー:
      UnsupportedOperationException - レーン値をint配列要素として表現できない場合
      関連項目:

    • toLongArray

      public abstract long[] toLongArray()
      long型に変換された、すべてのレーン値を含むlong[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 レーンに小数値または範囲外の値が含まれる場合、ベクトル要素タイプが floatまたはdoubleの場合、この演算は失敗する可能性があります。 ベクトル・レーン値がlongとして表現できない場合は、例外がスローされます。
      APIのノート:
      既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、「強い型指定のアクセス」をお薦めします。
      戻り値:
      このベクトルのレーン値を含むlong[]配列
      スロー:
      UnsupportedOperationException - レーン値をlong配列要素として表現できない場合
      関連項目:

    • toDoubleArray

      public abstract double[] toDoubleArray()
      double型に変換された、すべてのレーン値を含むdouble[]配列を返します。 配列の長さはベクトルの長さと同じです。 配列要素は、キャストによって変換され、レーン順に格納されます。 ベクトル要素タイプがlongの場合、この演算によって精度が失われる可能性があります。
      APIのノート:
      既知の要素タイプを持つVectorサブタイプを使用する場合は、通常、strongly typed accessをお薦めします。
      戻り値:
      このベクトルのレーン値を含むdouble[]配列。表現可能なdouble値に丸められる可能性がある
      関連項目:

    • toString

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

    • equals

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

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

      オーバーライド:
      equals、クラスObject
      パラメータ:
      obj - 比較対象の参照オブジェクト。
      戻り値:
      このベクトルがほかのオブジェクトと同一かどうか
      関連項目:

    • hashCode

      public abstract int hashCode()
      レーン値とベクトル種に基づいて、ベクトルのハッシュ・コード値を返します。
      オーバーライド:
      hashCode、クラスObject
      戻り値:
      このベクトルのハッシュ・コード値
      関連項目:

    • getPayload

      protected final Object getPayload()