Spec-Zone.ru › OpenJDK 24

Класс VectorShuffle<E>

java.lang.Object
jdk.incubator.vector.VectorShuffle<E>
Параметры типа:
E - упакованная версия ETYPE, тип элемента вектора
public abstract class VectorShuffle<E> extends Object
Объект VectorShuffle представляет собой упорядоченную неизменяемую последовательность int значений, называемых индексами источника, где каждый индекс источника численно выбирает целевой элемент из совместимого Vector.

Два VectorShuffle и Vector одного и того же типа элемента (ETYPE) и shape имеют одинаковое количество элементов, и поэтому совместимы (в частности, их vector species совместимы).

Перестановка применяется к вектору-источнику (совместимому) с помощью метода rearrange.

Перестановка имеет структуру элементов, полученную из её вида вектора, но она хранит индексы элементов, а не значения элементов.

Этот метод собирает значения элементов путём произвольного доступа к вектору-источнику, выбирая элементы, используя индексы источника. Если индекс источника встречается более одного раза в перестановке, то значение выбранного элемента копируется более одного раза в результат. Если конкретный элемент никогда не выбирается индексом источника, значение этого элемента игнорируется. Результирующий вектор содержит все значения элементов источника, выбранные индексами источника перестановки. Результирующие значения элементов упорядочены по индексам источника перестановки, а не по исходному порядку элементов вектора.

Каждая перестановка имеет свойство vectorSpecies(), которое определяет совместимость векторов, на которых она выполняется. Это гарантирует, что length() перестановки всегда равен VLENGTH любого вектора, на котором она выполняется. Тип элемента и форма вида перестановки не имеют прямого отношения к поведению перестановки. Перестановки легко могут быть преобразованы к другим типам элементов, при условии, что количество элементов остаётся постоянным.

Во внутреннем состоянии перестановка всегда хранит целые значения в узком диапазоне от [-VLENGTH..VLENGTH-1]. Положительные числа очевидны; они представляют номера элементов, применяемые к любому вектору-источнику. Отрицательные числа, если они присутствуют, указывают на то, что перестановка была создана из целого значения, которое не является корректным индексом элемента.

Некорректный индекс источника, представленный в перестановке отрицательным числом, называется исключительным индексом.

Исключительные индексы обрабатываются различными способами:

  • Если не указано иное, методы, использующие перестановку, будут выбрасывать ArrayIndexOutOfBoundsException, когда элемент обрабатывается исключительным индексом.
  • Когда некорректный индекс источника (отрицательный или нет) впервые загружается в перестановку, он частично нормализуется в отрицательный диапазон [-VLENGTH..-1], как если бы он был преобразован с помощью wrapIndex(). Такое обращение с исключительными индексами называется частичным обёрткой, потому что оно сохраняет различие между обычными и исключительными индексами, одновременно оборачивая их в смежные диапазоны положительных и неположительных чисел. Частично обернутый индекс позже может быть полностью обернут в положительный диапазон путём добавления окончательного смещения VLENGTH.
  • В некоторых приложениях исключительные индексы используются для «управления» доступом ко второму вектору-источнику. В этих случаях значения исключительных индексов, которые находятся в диапазоне [-VLENGTH..-1], циклически увеличиваются до допустимого диапазона [0..VLENGTH-1] и используются со вторым вектором-источником.
  • Когда перестановка преобразуется из перестановки другого вида с меньшим VLENGTH, все индексы повторно проверяются относительно нового VLENGTH, и некоторые из них могут быть преобразованы в исключительные индексы. В любом случае, преобразование перестановки никогда не преобразует исключительные индексы в обычные.

Классы на основе значений и операции с идентичностью

VectorShuffle, вместе с Vector является классом на основе значений. Операции, чувствительные к идентичности, такие как ==, могут давать непредсказуемые результаты или снижать производительность. Кроме того, объекты перестановки векторов могут храниться в локальных переменных и параметрах, а также как static final константы, но хранение их в других полях Java или в элементах массивов, хотя и семантически допустимо, может привести к снижению производительности. Наконец, перестановки векторов не следует вычислять в циклах, когда это возможно, а вместо этого следует хранить их в локальных переменных, не участвующих в цикле, или как static final константы.

Краткое описание методов

Модификатор и тип Метод Описание
abstract <F> VectorShuffle<F> cast(VectorSpecies<F> species)
Преобразует эту перестановку в перестановку заданного вида с типом элемента F.
abstract <F> VectorShuffle<F> check(VectorSpecies<F> species)
Проверяет, что эта перестановка имеет заданный вид, и возвращает эту перестановку без изменений.
abstract int checkIndex(int index)
Функция проверки для индексов элементов, которые могут быть вне допустимого диапазона [0..VLENGTH-1].
abstract VectorShuffle<E> checkIndexes()
Применяет функцию проверки checkIndex() ко всем элементам, выбрасывая IndexOutOfBoundsException, если в этой перестановке есть какие-либо исключительные индексы.
final boolean equals(Object obj)
Указывает, идентична ли эта перестановка другому объекту.
static <E> VectorShuffle<E> fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)
Создаёт перестановку для заданного вида из массива int, начиная с заданного смещения.
static <E> VectorShuffle<E> fromOp(VectorSpecies<E> species, IntUnaryOperator fn)
Создаёт перестановку для заданного вида из последовательных значений оператора, применённого к диапазону [0..VLENGTH-1].
static <E> VectorShuffle<E> fromValues(VectorSpecies<E> species, int... sourceIndexes)
Создаёт перестановку для заданного вида из набора индексов источника.
protected final Object getPayload()
final int hashCode()
Возвращает хеш-код перестановки, основанный на индексах элементов источника и виде вектора.
abstract void intoArray(int[] a, int offset)
Записывает эту перестановку в массив int, начиная с заданного смещения.
static <E> VectorShuffle<E> iota(VectorSpecies<E> species, int start, int step, boolean wrap)
Создаёт перестановку, используя индексы источника, установленные в последовательные значения, начинающиеся с start и шагом step.
abstract VectorMask<E> laneIsValid()
Находит все элементы, содержащие корректные индексы (положительные значения), и возвращает маску, где точно установлены эти элементы.
int laneSource(int i)
Возвращает элемент int элемента на индексе элемента i
final int length()
Возвращает количество обрабатываемых элементов в этой перестановке.
static <E> VectorShuffle<E> makeUnzip(VectorSpecies<E> species, int part)
Создаёт перестановку, которая будет распаковывать конкатенацию двух векторов, поочерёдно сохраняя входные элементы в один или другой выходной вектор.
static <E> VectorShuffle<E> makeZip(VectorSpecies<E> species, int part)
Создаёт перестановку, которая будет объединять два вектора, поочерёдно выбирая элементы из одного или другого.
abstract VectorShuffle<E> rearrange(VectorShuffle<E> s)
Переупорядочивает элементы в этой перестановке, выбирая индексы элементов, управляемые другой перестановкой.
abstract int[] toArray()
Возвращает массив int, содержащий индексы элементов источника этой перестановки.
final String toString()
Возвращает строковое представление этой перестановки, в формате "Shuffle[0,1,2...]", отображающее индексы элементов источника в порядке элементов.
abstract Vector<E> toVector()
Преобразует эту перестановку в вектор, создавая вектор целочисленных значений, соответствующих индексам элементов источника перестановки.
abstract VectorSpecies<E> vectorSpecies()
Возвращает вид этой перестановки.
abstract int wrapIndex(int index)
Функция проверки для индексов элементов, которые могут быть вне допустимого диапазона [0..VLENGTH-1].
abstract VectorShuffle<E> wrapIndexes()
Применяет функцию проверки wrapIndex() ко всем элементам, заменяя все исключительные индексы обернутыми обычными индексами.

Методы, объявленные в классе java.lang.Object

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

Подробности методов

vectorSpecies

public abstract VectorSpecies<E> vectorSpecies()
Возвращает вид этого перемешивания.
Возвращает:
вид этого перемешивания

length

public final int length()
Возвращает количество обрабатываемых линий этого перемешивания. Это то же самое, что и VLENGTH любого вектора, на котором оно работает.
Возвращает:
количество линий перемешивания

cast

public abstract <F> VectorShuffle<F> cast(VectorSpecies<F> species)
Преобразует это перемешивание в перемешивание заданного вида элемента типа F. Различные индексы исходных линий не изменяются. Исключительные индексы исходных данных остаются исключительными, а действительные индексы остаются действительными.
Параметры типа:
F - упакованный тип элемента вида
Параметры:
species - вид желаемого перемешивания
Возвращает:
перемешивание, преобразованное по форме и типу элемента
Выбрасывает:
IllegalArgumentException - если длина этого перемешивания и длина вида отличаются

check

public abstract <F> VectorShuffle<F> check(VectorSpecies<F> species)
Проверяет, что это перемешивание имеет заданный вид, и возвращает это перемешивание без изменений. Эффект аналогичен этому псевдокоду: species == vectorSpecies() ? this : throw new ClassCastException().
Параметры типа:
F - упакованный тип элемента требуемого вида
Параметры:
species - требуемый вид
Возвращает:
то же перемешивание
Выбрасывает:
ClassCastException - если вид перемешивания неверен
См. также:
  • Vector.check(Class)
  • Vector.check(VectorSpecies)

checkIndex

public abstract int checkIndex(int index)
Функция проверки для индексов линий, которые могут выходить за допустимый диапазон [0..VLENGTH-1]. Если index находится в этом диапазоне, он возвращается без изменений. В противном случае выбрасывается IndexOutOfBoundsException.
Параметры:
index - индекс линии
Возвращает:
index
Выбрасывает:
IndexOutOfBoundsException - если index не меньше VLENGTH или отрицательно
См. также:
  • wrapIndex(int)
  • checkIndexes()

wrapIndex

public abstract int wrapIndex(int index)
Функция проверки для индексов линий, которые могут выходить за допустимый диапазон [0..VLENGTH-1]. index принудительно переводится в этот диапазон путем добавления или вычитания соответствующего кратного VLENGTH. Конкретно, индекс уменьшается до требуемого диапазона, вычисляя значение length-floor, где floor=vectorSpecies().loopBound(length) - следующее меньшее кратное VLENGTH. Пока VLENGTH является степенью двойки, уменьшенный индекс также равен index & (VLENGTH - 1).
Параметры:
index - индекс линии
Возвращает:
index, скорректированный до диапазона [0..VLENGTH-1, с помощью соответствующего кратного VLENGTH
См. также:
  • VectorSpecies.loopBound(int)
  • checkIndex(int)
  • wrapIndexes()

checkIndexes

public abstract VectorShuffle<E> checkIndexes()
Применяет функцию валидации checkIndex() ко всем линиям, выбрасывая IndexOutOfBoundsException, если в этом перемешивании есть какие-либо исключительные индексы.
Возвращает:
текущее перемешивание, без изменений
Выбрасывает:
IndexOutOfBoundsException - если какие-либо линии в этом перемешивании содержат исключительные индексы
См. также:
  • checkIndex(int)
  • wrapIndexes()

wrapIndexes

public abstract VectorShuffle<E> wrapIndexes()
Применяет функцию валидации wrapIndex() ко всем линиям, заменяя любые исключительные индексы на обернутые обычные индексы.
Возвращает:
текущее перемешивание со всеми обернутыми исключительными индексами
См. также:
  • wrapIndex(int)
  • checkIndexes()

laneIsValid

public abstract VectorMask<E> laneIsValid()
Находит все линии, содержащие действительные индексы (неотрицательные значения), и возвращает маску, где точно установлены эти линии.
Возвращает:
маска линий, содержащих действительные индексы исходных данных
См. также:
  • checkIndexes()

fromValues

public static <E> VectorShuffle<E> fromValues(VectorSpecies<E> species, int... sourceIndexes)
Создаёт перемешивание для заданного вида из ряда индексов исходных данных.

Для каждой линии перемешивания, где N - индекс линии перемешивания, N-й индекс проверяется на соответствие виду VLENGTH, и (в случае несоответствия) частично оборачивается в исключительный индекс в диапазоне [-VLENGTH..-1].

Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перемешивания
sourceIndexes - индексы исходных данных, из которых будет браться перемешивание
Возвращает:
перемешивание, где индекс исходных данных каждой линии установлен на заданное int значение, частично обернутое, если исключительное
Выбрасывает:
IndexOutOfBoundsException - если sourceIndexes.length != VLENGTH
См. также:
  • VectorSpecies.shuffleFromValues(int...)

fromArray

public static <E> VectorShuffle<E> fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)
Создаёт перемешивание для заданного вида из массива исходных индексов, начиная с смещения.

Для каждой линии перемешивания, где N - индекс линии перемешивания, элемент массива с индексом offset + N проверяется на соответствие виду VLENGTH, и (в случае несоответствия) частично оборачивается в исключительный индекс в диапазоне [-VLENGTH..-1].

Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перемешивания
sourceIndexes - индексы исходных данных, из которых будет браться перемешивание
offset - смещение в массиве
Возвращает:
перемешивание, где индекс исходных данных каждой линии установлен на заданное int значение, частично обернутое, если исключительное
Выбрасывает:
IndexOutOfBoundsException - если offset < 0 или offset > sourceIndexes.length - VLENGTH
См. также:
  • VectorSpecies.shuffleFromArray(int[], int)

fromOp

public static <E> VectorShuffle<E> fromOp(VectorSpecies<E> species, IntUnaryOperator fn)
Создаёт перемешивание для заданного вида из последовательных значений оператора, применённого к диапазону [0..VLENGTH-1].

Для каждой линии перемешивания, где N - индекс линии перемешивания, N-й индекс проверяется на соответствие виду VLENGTH, и (в случае несоответствия) частично оборачивается в исключительный индекс в диапазоне [-VLENGTH..-1].

Следует позаботиться о том, чтобы значения VectorShuffle, полученные с помощью этого метода, потреблялись как константы, чтобы обеспечить оптимальную генерацию кода. Например, значения перемешивания могут храниться в static final полях или инвариантных переменных цикла.

Этот метод ведёт себя так, как будто перемешивание создаётся из массива индексов, преобразованных следующим образом:


   int[] a = new int[species.length()];
   for (int i = 0; i < a.length; i++) {
       a[i] = fn.applyAsInt(i);
   }
   return VectorShuffle.fromArray(a, 0);
 
Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перемешивания
fn - функция сопоставления индекса линии
Возвращает:
перемешивание сопоставленных индексов
См. также:
  • VectorSpecies.shuffleFromOp(IntUnaryOperator)

iota

public static <E> VectorShuffle<E> iota(VectorSpecies<E> species, int start, int step, boolean wrap)
Создает перестановку с использованием исходных индексов, установленных в последовательные значения, начиная с start и с шагом step.

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> R(start + i * step)), где R является wrapIndex, если wrap истинно, и является тождественной функцией в противном случае.

Если wrap ложно, каждый индекс проверяется на допустимость для вида VLENGTH, и (если недопустим) частично оборачивается в исключительный индекс в диапазоне [-VLENGTH..-1]. В противном случае, если wrap истинно, также уменьшает каждый индекс, как будто с помощью wrapIndex, до допустимого диапазона [0..VLENGTH-1].

API Note:
Параметр wrap должен быть установлен в true, если недопустимые исходные индексы должны быть обернуты. В противном случае, установка его в false позволяет проверять недопустимые исходные индексы на допустимость последующими операциями, такими как unary rearrange.
Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перестановки
start - начальное значение последовательности исходных индексов
step - разница между соседними исходными индексами
wrap - следует ли оборачивать результирующие индексы
Возвращает:
перестановка последовательных индексов полос, возможно, обернутая
См. также:
  • VectorSpecies.iotaShuffle(int,int,boolean)

makeZip

public static <E> VectorShuffle<E> makeZip(VectorSpecies<E> species, int part)
Создает перестановку, которая будет объединять два вектора, поочередно выбирая полосы из одного или другого. Логический результат объединения вдвое больше размера любого из входных данных, поэтому расширенный результат разделен на две физические части, выбранные по номеру части. Например, объединение двух векторов [a,b,c,d] и [1,2,3,4] даст расширенный логический результат [a,1,b,2,c,3,d,4], который должен быть получен в двух частях, [a,1,b,2] и [c,3,d,4].

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> i/2 + (i%2)*VLENGTH + P, где P является part*VLENGTH/2.

Обратите внимание, что исходные индексы в нечетных полосах перестановки будут недопустимыми индексами (>= VLENGTH или < 0 после частичной нормализации), которые будут выбраны из второго вектора.

Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перестановки
part - номер части результата (либо ноль, либо один)
Возвращает:
перестановка, которая объединяет два вектора в 2*VLENGTH полос, возвращая выбранную часть
Исключения:
ArrayIndexOutOfBoundsException - если part не ноль или один
См. также:
  • makeUnzip(VectorSpecies, int)
  • Vector.rearrange(VectorShuffle,Vector)

makeUnzip

public static <E> VectorShuffle<E> makeUnzip(VectorSpecies<E> species, int part)
Создает перестановку, которая будет распаковывать конкатенацию двух векторов, поочередно сохраняя входные полосы в один или другой выходной вектор. Поскольку логический результат распаковки вдвое больше размера любого из входных данных, расширенный результат разделен на две физические части, выбранные по номеру части. Например, распаковка двух векторов [a,1,b,2][c,3,d,4] даст результат в двух частях, [a,b,c,d] и [1,2,3,4].

Этот метод возвращает значение выражения VectorShuffle.fromOp(species, i -> i*2+part.

Обратите внимание, что исходные индексы в верхней половине перестановки будут недопустимыми индексами (>= VLENGTH или < 0 после частичной нормализации), которые будут выбраны из второго вектора.

Параметры типа:
E - упакованный тип элемента
Параметры:
species - вид перестановки
part - номер части результата (либо ноль, либо один)
Возвращает:
перестановка, которая распаковывает 2*VLENGTH полос в два вектора, возвращая выбранную часть
Исключения:
ArrayIndexOutOfBoundsException - если part не ноль или один
См. также:
  • makeZip(VectorSpecies,int)
  • Vector.rearrange(VectorShuffle,Vector)

toArray

public abstract int[] toArray()
Возвращает массив int, содержащий исходные индексы полос этой перестановки.

Этот метод работает так, как будто он сохраняет эту перестановку в выделенный массив (используя intoArray) и возвращает этот массив следующим образом:


   int[] a = new int[this.length()];
   VectorShuffle.intoArray(a, 0);
   return a;
 
API Note:
Исходные индексы перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1. Исходный индекс является исключительным тогда и только тогда, когда он отрицателен.
Возвращает:
массив, содержащий исходные индексы полос этой перестановки

intoArray

public abstract void intoArray(int[] a, int offset)
Сохраняет эту перестановку в массив int, начиная с смещения.

Для каждой полосы перестановки N исходный индекс полосы, сохраненный для этого элемента полосы, сохраняется в элементе массива a[offset+N].

API Note:
Исходные индексы перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1.
Параметры:
a - массив типа int[]
offset - смещение в массиве
Исключения:
IndexOutOfBoundsException - если offset < 0 или offset > a.length - this.length()

toVector

public abstract Vector<E> toVector()
Преобразует эту перестановку в вектор, создавая вектор целочисленных значений, соответствующих исходным индексам полос перестановки.

Этот метод работает так, как будто он возвращает результат создания вектора, учитывая массив int, полученный из элементов полос этой перестановки, следующим образом:


   int[] sa = this.toArray();
   $type$[] va = new $type$[a.length];
   for (int i = 0; i < a.length; i++) {
       va[i] = ($type$) sa[i];
   }
   return IntVector.fromArray(va, 0);
 
API Note:
Исходные индексы перестановки всегда находятся в диапазоне от -VLENGTH до VLENGTH-1. Эти значения преобразуются в ETYPE результирующего вектора, даже если это тип с плавающей точкой.
Возвращает:
векторное представление этой перестановки

laneSource

public int laneSource(int i)
Получает элемент полосы int с индексом полосы i
Параметры:
i - индекс полосы
Возвращает:
элемент полосы int с индексом полосы i

rearrange

public abstract VectorShuffle<E> rearrange(VectorShuffle<E> s)
Переставляет элементы полос этой перестановки, выбирая индексы полос, управляемые другой перестановкой.

Для каждой полосы указанной перестановки, с индексом полосы N и элементом полосы I, элемент полосы по I из этой перестановки выбирается и помещается в результирующую перестановку по N.

Параметры:
s - перестановка, управляющая выбором индекса полосы
Возвращает:
перестановка элементов полос этой перестановки

toString

public final String toString()
Возвращает строковое представление этой перестановки в форме "Shuffle[0,1,2...]", сообщая исходные индексы в порядке полос.
Переопределяет:
toString в классе Object
Возвращает:
строку в форме "Shuffle[0,1,2...]"

equals

public final boolean equals(Object obj)
Указывает, идентична ли эта перестановка какому-либо другому объекту. Две перестановки идентичны только в том случае, если у них одинаковый вид и одинаковые исходные индексы в том же порядке.
Переопределяет:
equals в классе Object
Параметры:
obj - объектный ссылочный тип для сравнения.
Возвращает:
является ли этот вектор идентичным какому-либо другому объекту
См. также:
  • Object.hashCode()
  • HashMap

hashCode

public final int hashCode()
Возвращает хэш-код для перемешивания, основанный на индексах источника дорожки и виде вектора.
Overrides:
hashCode в классе Object
Возвращает:
хэш-код для этого перемешивания
См. также:
  • Object.equals(java.lang.Object)
  • System.identityHashCode(java.lang.Object)

getPayload

protected final Object getPayload()

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://download.java.net/java/early_access/jdk24/docs/api/jdk.incubator.vector/jdk/incubator/vector/VectorShuffle.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API