Класс ByteVector

java.lang.Object

jdk.incubator.vector.Vector<Byte>

jdk.incubator.vector.ByteVector

public abstract class ByteVector extends Vector<Byte>

Специализированный Vector, представляющий упорядоченную неизменяемую последовательность значений byte.

Краткое описание полей

Модификатор и тип	Поле	Описание
`static final VectorSpecies<Byte>`	`SPECIES_128`	Вид, представляющий `ByteVector` с размером `VectorShape.S_128_BIT`.
`static final VectorSpecies<Byte>`	`SPECIES_256`	Вид, представляющий `ByteVector` с размером `VectorShape.S_256_BIT`.
`static final VectorSpecies<Byte>`	`SPECIES_512`	Вид, представляющий `ByteVector` с размером `VectorShape.S_512_BIT`.
`static final VectorSpecies<Byte>`	`SPECIES_64`	Вид, представляющий `ByteVector` с размером `VectorShape.S_64_BIT`.
`static final VectorSpecies<Byte>`	`SPECIES_MAX`	Вид, представляющий `ByteVector` с размером `VectorShape.S_Max_BIT`.
`static final VectorSpecies<Byte>`	`SPECIES_PREFERRED`	Предпочтительный вид для `ByteVector`.

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

Модификатор и тип	Метод	Описание
`final ByteVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final ByteVector`	`add(byte e)`	Прибавляет к этому вектору значение входного скаляра, транслированное на все элементы.
`final ByteVector`	`add(byte e, VectorMask<Byte> m)`	Прибавляет к этому вектору значение входного скаляра, транслированное на все элементы, выбирая элементы согласно маске.
`final ByteVector`	`add(Vector<Byte> v)`	Прибавляет к этому вектору второй входной вектор.
`final ByteVector`	`add(Vector<Byte> v, VectorMask<Byte> m)`	Прибавляет к этому вектору второй входной вектор, выбирая элементы согласно маске.
`abstract ByteVector`	`addIndex(int scale)`	Прибавляет к элементам этого вектора соответствующие им номера элементов, умноженные на заданную константу.
`final ByteVector`	`and(byte e)`	Вычисляет побитовое логическое И (`&`) этого вектора и скаляра.
`final ByteVector`	`and(Vector<Byte> v)`	Вычисляет побитовое логическое И (`&`) этого вектора и второго входного вектора.
`final ByteVector`	`bitwiseBlend(byte bits, byte mask)`	Объединяет биты вектора и скаляра под управлением другого скаляра, задающего биты маски.
`final ByteVector`	`bitwiseBlend(byte bits, Vector<Byte> mask)`	Объединяет биты вектора и скаляра под управлением другого вектора, задающего биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, byte mask)`	Объединяет биты двух векторов под управлением скаляра, задающего биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)`	Объединяет биты двух векторов под управлением третьего вектора, задающего биты маски.
`final ByteVector`	`blend(byte e, VectorMask<Byte> m)`	Заменяет выбранные элементы этого вектора скалярным значением согласно маске.
`final ByteVector`	`blend(long e, VectorMask<Byte> m)`	Заменяет выбранные элементы этого вектора скалярным значением согласно маске.
`abstract ByteVector`	`blend(Vector<Byte> v, VectorMask<Byte> m)`	Заменяет выбранные элементы этого вектора соответствующими элементами второго входного вектора согласно маске.
`abstract ByteVector`	`broadcast(byte e)`	Возвращает вектор того же вида, что и этот, у которого всем элементам присвоено примитивное значение `e`.
`abstract ByteVector`	`broadcast(long e)`	Возвращает вектор того же вида, что и этот, у которого всем элементам присвоено примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, byte e)`	Возвращает вектор указанного вида, у которого всем элементам присвоено примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, long e)`	Возвращает вектор указанного вида, у которого всем элементам присвоено примитивное значение `e`.
`final <F> Vector<F>`	`castShape(VectorSpecies<F> toSpecies, int part)`	Вспомогательный метод для преобразования вектора из одного типа элементов в другой с изменением формы при необходимости, если меняется размер элементов.
`final <F> Vector<F>`	`check(Class<F> elementType)`	Проверяет, что этот вектор имеет указанный тип элементов, и возвращает его без изменений.
`final <F> Vector<F>`	`check(VectorSpecies<F> species)`	Проверяет, что этот вектор имеет указанный вид, и возвращает его без изменений.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e)`	Сравнивает этот вектор с входным скаляром согласно заданной операции сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)`	Сравнивает этот вектор с входным скаляром согласно заданной операции сравнения для элементов, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e)`	Сравнивает этот вектор с входным скаляром согласно заданной операции сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)`	Сравнивает этот вектор с входным скаляром согласно заданной операции сравнения для элементов, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, Vector<Byte> v)`	Сравнивает этот вектор с другим входным вектором согласно заданной операции сравнения.
`abstract ByteVector`	`compress(VectorMask<Byte> m)`	Сжимает элементы этого вектора, выбирая их согласно заданной маске.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Byte,F> conv, int part)`	Преобразует этот вектор в вектор той же формы с новым типом элементов, преобразуя значения элементов из текущего `ETYPE` в новый тип элементов (здесь называемый `FTYPE`) согласно указанному преобразованию.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Byte,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор указанного вида, формы и типа элементов, преобразуя значения элементов из текущего `ETYPE` в новый тип элементов (здесь называемый `FTYPE`) согласно указанному преобразованию.
`final ByteVector`	`div(byte e)`	Делит этот вектор на входной скаляр, транслированный на все элементы.
`final ByteVector`	`div(byte e, VectorMask<Byte> m)`	Делит этот вектор на входной скаляр, транслированный на все элементы, выбирая элементы согласно маске.
`final ByteVector`	`div(Vector<Byte> v)`	Делит этот вектор на второй входной вектор.
`final ByteVector`	`div(Vector<Byte> v, VectorMask<Byte> m)`	Делит этот вектор на второй входной вектор согласно маске.
`final VectorMask<Byte>`	`eq(byte e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Byte>`	`eq(Vector<Byte> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор другому объекту.
`abstract ByteVector`	`expand(VectorMask<Byte> m)`	Расширяет элементы этого вектора согласно заданной маске.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset)`	Загружает вектор из массива типа `byte[]`, начиная с заданного смещения.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)`	Собирает новый вектор из элементов массива типа `byte[]`, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Собирает новый вектор из элементов массива типа `byte[]` согласно маске, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)`	Загружает вектор из массива типа `byte[]`, начиная с заданного смещения и используя маску.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset)`	Загружает вектор из массива типа `boolean[]`, начиная с заданного смещения.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset)`	Собирает новый вектор из элементов массива типа `boolean[]`, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Собирает новый вектор из элементов массива типа `boolean[]` согласно маске, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)`	Загружает вектор из массива типа `boolean[]`, начиная с заданного смещения и используя маску.
`static ByteVector`	`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная с заданного смещения в сегменте памяти.
`static ByteVector`	`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)`	Загружает вектор из сегмента памяти, начиная с заданного смещения в сегменте памяти и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает хеш-код вектора, основанный на значениях его элементов и виде вектора.
`final void`	`intoArray(byte[] a, int offset)`	Сохраняет этот вектор в массив типа `byte[]`, начиная с заданного смещения.
`final void`	`intoArray(byte[] a, int offset, int[] indexMap, int mapOffset)`	Распределяет элементы этого вектора по массиву типа `byte[]`, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`final void`	`intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Распределяет элементы этого вектора по массиву типа `byte[]` согласно маске, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`final void`	`intoArray(byte[] a, int offset, VectorMask<Byte> m)`	Сохраняет этот вектор в массив типа `byte[]`, начиная с заданного смещения и используя маску.
`final void`	`intoBooleanArray(boolean[] a, int offset)`	Сохраняет этот вектор в массив типа `boolean[]`, начиная с заданного смещения.
`final void`	`intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset)`	Распределяет элементы этого вектора по массиву типа `boolean[]`, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`final void`	`intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Распределяет элементы этого вектора по массиву типа `boolean[]` согласно маске, используя индексы, полученные добавлением фиксированного `offset` к последовательности дополнительных смещений из карты индексов.
`final void`	`intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m)`	Сохраняет этот вектор в массив типа `boolean[]`, начиная с заданного смещения и используя маску.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения и используя явно заданный порядок байтов.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)`	Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения, используя явно заданный порядок байтов и маску.
`abstract byte`	`lane(int i)`	Получает элемент вектора с индексом `i`
`final ByteVector`	`lanewise(VectorOperators.Binary op, byte e)`	Объединяет значения элементов этого вектора со значением транслированного скаляра.
`final ByteVector`	`lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)`	Объединяет значения элементов этого вектора со значением транслированного скаляра, выбирая элементы согласно маске.
`final ByteVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения элементов этого вектора со значением транслированного скаляра.
`final ByteVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)`	Объединяет значения соответствующих элементов этого вектора и второго входного вектора, выбирая элементы согласно маске.
`abstract ByteVector`	`lanewise(VectorOperators.Binary op, Vector<Byte> v)`	Объединяет значения соответствующих элементов этого вектора и второго входного вектора.
`abstract ByteVector`	`lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)`	Объединяет значения соответствующих элементов этого вектора и второго входного вектора, выбирая элементы согласно маске.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, byte e2)`	Объединяет значения элементов этого вектора со значениями двух транслированных скаляров.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)`	Объединяет значения элементов этого вектора со значениями двух транслированных скаляров, выбирая элементы согласно маске.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)`	Объединяет значения элементов этого вектора со значениями другого вектора и транслированного скаляра.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)`	Объединяет значения элементов этого вектора со значениями другого вектора и транслированного скаляра, выбирая элементы согласно маске.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)`	Объединяет значения элементов этого вектора со значениями другого вектора и транслированного скаляра.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)`	Объединяет значения элементов этого вектора со значениями другого вектора и транслированного скаляра, выбирая элементы согласно маске.
`abstract ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)`	Объединяет значения соответствующих элементов этого вектора с элементами второго и третьего входных векторов.
`abstract ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)`	Объединяет значения соответствующих элементов этого вектора с элементами второго и третьего входных векторов, выбирая элементы согласно маске.
`abstract ByteVector`	`lanewise(VectorOperators.Unary op)`	Выполняет операцию над значениями элементов этого вектора.
`abstract ByteVector`	`lanewise(VectorOperators.Unary op, VectorMask<Byte> m)`	Выполняет операцию над значениями элементов этого вектора, выбирая элементы согласно маске.
`final VectorMask<Byte>`	`lt(byte e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Byte>`	`lt(Vector<Byte> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Byte>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор, в которой каждый элемент установлен или сброшен согласно заданному логическому значению, транслированному на все элементы.
`final ByteVector`	`max(byte e)`	Вычисляет максимум этого вектора и входного скаляра, транслированного на все элементы.
`final ByteVector`	`max(Vector<Byte> v)`	Вычисляет максимум этого вектора и второго входного вектора.
`final ByteVector`	`min(byte e)`	Вычисляет минимум этого вектора и входного скаляра, транслированного на все элементы.
`final ByteVector`	`min(Vector<Byte> v)`	Вычисляет минимум этого вектора и второго входного вектора.
`final ByteVector`	`mul(byte e)`	Умножает этот вектор на входной скаляр, транслированный на все элементы.
`final ByteVector`	`mul(byte e, VectorMask<Byte> m)`	Умножает этот вектор на входной скаляр, транслированный на все элементы, выбирая элементы согласно маске.
`final ByteVector`	`mul(Vector<Byte> v)`	Умножает этот вектор на второй входной вектор.
`final ByteVector`	`mul(Vector<Byte> v, VectorMask<Byte> m)`	Умножает этот вектор на второй входной вектор согласно маске.
`final ByteVector`	`neg()`	Меняет знак этого вектора.
`final ByteVector`	`not()`	Вычисляет побитовое логическое дополнение (`~`) этого вектора.
`final ByteVector`	`or(byte e)`	Вычисляет побитовое логическое ИЛИ (`\|`) этого вектора и скаляра.
`final ByteVector`	`or(Vector<Byte> v)`	Вычисляет побитовое логическое ИЛИ (`\|`) этого вектора и второго входного вектора.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> shuffle)`	Переставляет элементы этого вектора, выбирая их согласно заданной схеме перестановки.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`	Переставляет элементы двух векторов, выбирая их согласно заданной схеме перестановки и используя в ней обычные и специальные индексы для направления данных.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)`	Переставляет элементы этого вектора, выбирая их согласно заданной схеме перестановки и маске.
`abstract byte`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, полученное сверткой всех элементов этого вектора.
`abstract byte`	`reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)`	Возвращает значение, полученное сверткой выбранных элементов этого вектора согласно маске.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `byte`; байты извлекаются из элементов в порядке от младшего к старшему.
`DoubleVector`	`reinterpretAsDoubles()`	Интерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `double`; элементы собираются из последовательных байтов в порядке от младшего к старшему.
`FloatVector`	`reinterpretAsFloats()`	Интерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `float`; элементы собираются из последовательных байтов в порядке от младшего к старшему.
`IntVector`	`reinterpretAsInts()`	Интерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `int`; элементы собираются из последовательных байтов в порядке от младшего к старшему.
`LongVector`	`reinterpretAsLongs()`	Интерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `long`; элементы собираются из последовательных байтов в порядке от младшего к старшему.
`ShortVector`	`reinterpretAsShorts()`	Интерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `short`; элементы собираются из последовательных байтов в порядке от младшего к старшему.
`abstract ByteVector`	`selectFrom(Vector<Byte> v)`	Используя значения индексов в элементах этого вектора, собирает значения из второго вектора `v`.
`abstract ByteVector`	`selectFrom(Vector<Byte> v1, Vector<Byte> v2)`	Используя значения в элементах этого вектора, собирает значения из второго вектора `v1` и третьего вектора `v2`.
`abstract ByteVector`	`selectFrom(Vector<Byte> s, VectorMask<Byte> m)`	Используя значения индексов в элементах этого вектора, собирает значения из второго вектора согласно маске.
`abstract ByteVector`	`slice(int origin)`	Извлекает сегмент смежных элементов, начиная с заданного элемента `origin` в текущем векторе.
`abstract ByteVector`	`slice(int origin, Vector<Byte> v1)`	Извлекает сегмент смежных элементов, начиная с заданного элемента `origin` в текущем векторе и при необходимости продолжая в непосредственно следующем векторе.
`final ByteVector`	`slice(int origin, Vector<Byte> w, VectorMask<Byte> m)`	Извлекает сегмент смежных элементов согласно маске, начиная с заданного элемента `origin` в текущем векторе и при необходимости продолжая в непосредственно следующем векторе.
`final VectorSpecies<Byte>`	`species()`	Возвращает вид этого вектора.
`final ByteVector`	`sub(byte e)`	Вычитает входной скаляр из этого вектора.
`final ByteVector`	`sub(byte e, VectorMask<Byte> m)`	Вычитает входной скаляр из этого вектора согласно маске.
`final ByteVector`	`sub(Vector<Byte> v)`	Вычитает второй входной вектор из этого вектора.
`final ByteVector`	`sub(Vector<Byte> v, VectorMask<Byte> m)`	Вычитает второй входной вектор из этого вектора согласно маске.
`abstract VectorMask<Byte>`	`test(VectorOperators.Test op)`	Проверяет элементы этого вектора согласно заданной операции.
`abstract VectorMask<Byte>`	`test(VectorOperators.Test op, VectorMask<Byte> m)`	Проверяет выбранные элементы этого вектора согласно заданной операции.
`final byte[]`	`toArray()`	Возвращает массив типа `byte[]`, содержащий значения всех элементов.
`final double[]`	`toDoubleArray()`	Возвращает массив `double[]`, содержащий все значения элементов, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив `int[]`, содержащий все значения элементов, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает массив `long[]`, содержащий все значения элементов, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора вида `"[0,1,2...]"`, содержащее значения его элементов в порядке их расположения.
`abstract ByteVector`	`unslice(int origin)`	Отменяет операцию slice(), вставляя этот вектор как сегмент в «фоновый» вход, заполненный нулевыми значениями элементов.
`abstract ByteVector`	`unslice(int origin, Vector<Byte> w, int part)`	Отменяет операцию slice(), вставляя этот вектор как сегмент в другой «фоновый» входной вектор, который рассматривается как один из входов гипотетической последующей операции `slice()`.
`abstract ByteVector`	`unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)`	Отменяет операцию slice(), вставляя этот вектор как сегмент в другой «фоновый» входной вектор согласно маске; этот вектор рассматривается как один из входов гипотетической последующей операции `slice()`.
`final Vector<?>`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор той же формы, длины и с тем же содержимым, но с типом элементов с плавающей точкой.
`final ByteVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор той же формы, длины и с тем же содержимым, но с типом элементов, не являющимся типом с плавающей точкой.
`abstract ByteVector`	`withLane(int i, byte e)`	Заменяет элемент этого вектора с индексом `i` значением `e`.
`static ByteVector`	`zero(VectorSpecies<Byte> species)`	Возвращает вектор указанного вида, у которого всем элементам присвоен ноль — примитивное значение по умолчанию.

Методы, объявленные в классе Vector

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

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

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

Подробное описание полей

SPECIES_64

public static final VectorSpecies<Byte> SPECIES_64

Тип, представляющий ByteVector-векторы формы VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Byte> SPECIES_128

Тип, представляющий ByteVector-векторы формы VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Byte> SPECIES_256

Тип, представляющий ByteVector-векторы формы VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Byte> SPECIES_512

Тип, представляющий ByteVector-векторы формы VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Byte> SPECIES_MAX

Тип, представляющий ByteVector-векторы формы VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Byte> SPECIES_PREFERRED

Предпочтительный тип для ByteVector-векторов. Предпочтительный тип — это тип с максимальным размером в битах для данной платформы.

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

zero

public static ByteVector zero(VectorSpecies<Byte> species)

Возвращает вектор заданного типа, в котором все элементы lane установлены в ноль — значение примитивного типа по умолчанию.

Параметры:: species — тип желаемого нулевого вектора
Возвращает:: нулевой вектор

broadcast

public abstract ByteVector broadcast(byte e)

Возвращает вектор того же типа, что и данный, в котором все элементы lane установлены в примитивное значение e. Содержимое текущего вектора отбрасывается; для этой операции имеет значение только его тип.

Этот метод возвращает значение следующего выражения: ByteVector.broadcast(this.species(), e).

Примечание API:

В отличие от аналогичного метода с именем broadcast() в суперклассе Vector, этому методу не нужно проверять аргумент, и он не может выбросить IllegalArgumentException. Поэтому этот метод предпочтительнее метода суперкласса.

Параметры:

e — значение для широковещательной передачи

Возвращает:

вектор, в котором все элементы lane установлены в примитивное значение e

См. также:

broadcast

public static ByteVector broadcast(VectorSpecies<Byte> species, byte e)

Возвращает вектор заданного типа, в котором все элементы lane установлены в примитивное значение e.

Параметры:

species — тип желаемого вектора

e — значение для широковещательной передачи

Возвращает:

вектор, в котором все элементы lane установлены в примитивное значение e

См. также:

broadcast

public abstract ByteVector broadcast(long e)

Этот метод возвращает значение следующего выражения: EVector.broadcast(this.species(), (ETYPE)e), где EVector — класс вектора, специфичный для типа элементов этого вектора ETYPE.

Значение long e должно точно представляться типом ETYPE данного типа вектора, чтобы выполнялось условие e==(long)(ETYPE)e. Если это правило нарушено, проблема не обнаруживается статически, но во время выполнения выбрасывается IllegalArgumentException. Таким образом, этот метод несколько ослабляет статическую проверку типов для непосредственных констант и других скалярных значений, но компенсирует это повышением выразительности обобщённого API. Обратите внимание, что значение e в диапазоне [-128..127] всегда допустимо, поскольку любой ETYPE принимает любое значение byte.

Определено в:

broadcast в классе Vector<Byte>

Примечание API:

При работе с подтипами векторов, такими как ByteVector, обычно выбирается метод с более строгой типизацией. Его можно выбрать явно с помощью приведения типа: v.broadcast((byte)e). Оба выражения дают численно идентичные результаты.

Параметры:

e — значение для широковещательной передачи

Возвращает:

вектор, в котором все элементы lane установлены в примитивное значение e

См. также:

broadcast

public static ByteVector broadcast(VectorSpecies<Byte> species, long e)

Возвращает вектор заданного типа, в котором все элементы lane установлены в примитивное значение e. Значение long должно точно представляться типом ETYPE данного типа вектора, чтобы выполнялось условие e==(long)(ETYPE)e.

Параметры:

species — тип желаемого вектора

e — значение для широковещательной передачи

Возвращает:

вектор, в котором все элементы lane установлены в примитивное значение e

Выбрасывает:

IllegalArgumentException — если заданное значение long не может быть представлено типом ETYPE вектора

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Unary op)

Выполняет операцию над значениями элементов lane этого вектора. Это унарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane.

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для обработки значений элементов lane

Возвращает:

результат применения операции к каждому элементу lane входного вектора

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Unary op, VectorMask<Byte> m)

Выполняет операцию над значениями элементов lane этого вектора; выбор элементов lane управляется маской. Это унарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane.

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для обработки значений элементов lane

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входного вектора

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Binary op, Vector<Byte> v)

Объединяет соответствующие значения элементов lane этого вектора со значениями второго входного вектора. Это бинарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane.

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для объединения значений элементов lane

v — входной вектор

Возвращает:

результат применения операции к каждому элементу lane двух входных векторов

См. также:

lanewise

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

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для объединения значений элементов lane

v — второй входной вектор

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane двух входных векторов

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Binary op, byte e)

Объединяет значения элементов lane этого вектора со значением скаляра, передаваемого широковещательно. Это бинарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e)).

Параметры:

op — операция для обработки значений элементов lane

e — входной скаляр

Возвращает:

результат применения операции к каждому элементу lane двух входных векторов

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)

Объединяет значения элементов lane этого вектора со значением скаляра, передаваемого широковещательно; выбор элементов lane управляется маской. Это маскированная бинарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e), m).

Параметры:

op — операция для обработки значений элементов lane

e — входной скаляр

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входного вектора и скаляра

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

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

Определено в:

lanewise в классе Vector<Byte>

Примечание API:

При работе с подтипами векторов, такими как ByteVector, обычно выбирается метод с более строгой типизацией. Его можно выбрать явно с помощью приведения типа: v.lanewise(op,(byte)e). Оба выражения дают численно идентичные результаты.

Параметры:

op — операция для объединения значений элементов lane

e — входной скаляр

Возвращает:

результат применения операции к каждому элементу lane входного вектора и скаляра

См. также:

lanewise

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

Объединяет соответствующие значения элементов lane этого вектора со значениями второго входного вектора; выбор элементов lane управляется маской. Это бинарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Второй операнд — широковещательно передаваемое целочисленное значение. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e), m).

Определено в:

lanewise в классе Vector<Byte>

Примечание API:

При работе с подтипами векторов, такими как ByteVector, обычно выбирается метод с более строгой типизацией. Его можно выбрать явно с помощью приведения типа: v.lanewise(op,(byte)e,m). Оба выражения дают численно идентичные результаты.

Параметры:

op — операция для объединения значений элементов lane

e — входной скаляр

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входного вектора и скаляра

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)

Объединяет соответствующие значения элементов lane этого вектора со значениями элементов lane второго и третьего входных векторов. Это тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane.

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для объединения значений элементов lane

v1 — второй входной вектор

v2 — третий входной вектор

Возвращает:

результат применения операции к каждому элементу lane трёх входных векторов

См. также:

lanewise

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

Объединяет соответствующие значения элементов lane этого вектора со значениями элементов lane второго и третьего входных векторов; выбор элементов lane управляется маской. Это тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane.

Определено в:

lanewise в классе Vector<Byte>

Параметры:

op — операция для объединения значений элементов lane

v1 — второй входной вектор

v2 — третий входной вектор

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane трёх входных векторов

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, byte e2)

Объединяет значения элементов lane этого вектора со значениями двух скаляров, передаваемых широковещательно. Это тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e1), this.broadcast(e2)).

Параметры:

op — операция для объединения значений элементов lane

e1 — первый входной скаляр

e2 — второй входной скаляр

Возвращает:

результат применения операции к каждому элементу lane входного вектора и скаляров

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)

Объединяет значения элементов lane этого вектора со значениями двух скаляров, передаваемых широковещательно; выбор элементов lane управляется маской. Это маскированная тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m).

Параметры:

op — операция для объединения значений элементов lane

e1 — первый входной скаляр

e2 — второй входной скаляр

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входного вектора и скаляров

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)

Объединяет значения элементов lane этого вектора со значениями другого вектора и скаляра, передаваемого широковещательно. Это тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, v1, this.broadcast(e2)).

Параметры:

op — операция для объединения значений элементов lane

v1 — другой входной вектор

e2 — входной скаляр

Возвращает:

результат применения операции к каждому элементу lane входных векторов и скаляра

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)

Объединяет значения элементов lane этого вектора со значениями другого вектора и скаляра, передаваемого широковещательно; выбор элементов lane управляется маской. Это маскированная тернарная операция над элементами lane, которая применяет выбранную операцию к каждому элементу lane. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, v1, this.broadcast(e2), m).

Параметры:

op — операция для объединения значений элементов lane

v1 — другой входной вектор

e2 — входной скаляр

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входных векторов и скаляра

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)

Параметры:

op — операция для объединения значений элементов lane

e1 — входной скаляр

v2 — другой входной вектор

Возвращает:

результат применения операции к каждому элементу lane входных векторов и скаляра

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

lanewise

public final ByteVector lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)

Параметры:

op — операция для объединения значений элементов lane

e1 — входной скаляр

v2 — другой входной вектор

m — маска, управляющая выбором элементов lane

Возвращает:

результат применения операции к каждому элементу lane входных векторов и скаляра

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

add

public final ByteVector add(Vector<Byte> v)

Складывает этот вектор со вторым входным вектором. Это поэлементная бинарная операция, которая применяет примитивную операцию сложения (+) к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(ADD, v).

Этот метод как полноценная именованная операция имеет перегрузки с маской и без неё, а также (в подклассах) перегрузки с передачей скалярного значения, транслируемого во все элементы (с маской и без неё).

Переопределяет:

add в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

результат сложения этого вектора со вторым входным вектором

См. также:

add

public final ByteVector add(byte e)

Складывает этот вектор с входным скалярным значением, транслируемым во все элементы. Это поэлементная бинарная операция, которая применяет примитивную операцию сложения (+) к каждому элементу. Этот метод также эквивалентен выражению lanewise(ADD, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат сложения каждого элемента этого вектора со скалярным значением

См. также:

add

public final ByteVector add(Vector<Byte> v, VectorMask<Byte> m)

Складывает этот вектор со вторым входным вектором, выбирая элементы под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию сложения (+) к каждой паре соответствующих элементов векторов. Для каждого элемента, не выбранного маской, примитивная операция не выполняется, и этот вектор сохраняет исходное значение, хранящееся в этом элементе. Этот метод также эквивалентен выражению lanewise(ADD, v, m).

Переопределяет:

add в классе Vector<Byte>

Параметры:

v — второй входной вектор

m — маска, управляющая выбором элементов

Возвращает:

результат сложения этого вектора с заданным вектором

См. также:

add

public final ByteVector add(byte e, VectorMask<Byte> m)

Складывает этот вектор с входным скалярным значением, транслируемым во все элементы, выбирая элементы под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию сложения (+) к каждому элементу. Этот метод также эквивалентен выражению lanewise(ADD, s, m).

Параметры:

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

результат сложения каждого элемента этого вектора со скалярным значением

См. также:

sub

public final ByteVector sub(Vector<Byte> v)

Вычитает второй входной вектор из этого вектора. Это поэлементная бинарная операция, которая применяет примитивную операцию вычитания (-) к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(SUB, v).

Переопределяет:

sub в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

результат вычитания второго входного вектора из этого вектора

См. также:

sub

public final ByteVector sub(byte e)

Вычитает входное скалярное значение из этого вектора. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию вычитания (-) к каждому элементу. Этот метод также эквивалентен выражению lanewise(SUB, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат вычитания скалярного значения из каждого элемента этого вектора

См. также:

sub

public final ByteVector sub(Vector<Byte> v, VectorMask<Byte> m)

Вычитает второй входной вектор из этого вектора под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию вычитания (-) к каждой паре соответствующих элементов векторов. Для каждого элемента, не выбранного маской, примитивная операция не выполняется, и этот вектор сохраняет исходное значение, хранящееся в этом элементе. Этот метод также эквивалентен выражению lanewise(SUB, v, m).

Переопределяет:

sub в классе Vector<Byte>

Параметры:

v — второй входной вектор

m — маска, управляющая выбором элементов

Возвращает:

результат вычитания второго входного вектора из этого вектора

См. также:

sub

public final ByteVector sub(byte e, VectorMask<Byte> m)

Вычитает входное скалярное значение из этого вектора под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию вычитания (-) к каждому элементу. Этот метод также эквивалентен выражению lanewise(SUB, s, m).

Параметры:

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

результат вычитания скалярного значения из каждого элемента этого вектора

См. также:

mul

public final ByteVector mul(Vector<Byte> v)

Умножает этот вектор на второй входной вектор. Это поэлементная бинарная операция, которая применяет примитивную операцию умножения (*) к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(MUL, v).

Переопределяет:

mul в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

результат умножения этого вектора на второй входной вектор

См. также:

mul

public final ByteVector mul(byte e)

Умножает этот вектор на входное скалярное значение, транслируемое во все элементы. Это поэлементная бинарная операция, которая применяет примитивную операцию умножения (*) к каждому элементу. Этот метод также эквивалентен выражению lanewise(MUL, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат умножения этого вектора на заданное скалярное значение

См. также:

mul

public final ByteVector mul(Vector<Byte> v, VectorMask<Byte> m)

Умножает этот вектор на второй входной вектор под управлением маски. Это поэлементная бинарная операция, которая применяет примитивную операцию умножения (*) к каждой паре соответствующих элементов векторов. Для каждого элемента, не выбранного маской, примитивная операция не выполняется, и этот вектор сохраняет исходное значение, хранящееся в этом элементе. Этот метод также эквивалентен выражению lanewise(MUL, v, m).

Переопределяет:

mul в классе Vector<Byte>

Параметры:

v — второй входной вектор

m — маска, управляющая выбором элементов

Возвращает:

результат умножения этого вектора на заданный вектор

См. также:

mul

public final ByteVector mul(byte e, VectorMask<Byte> m)

Умножает этот вектор на входное скалярное значение, транслируемое во все элементы, выбирая элементы под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию умножения (*) к каждому элементу. Этот метод также эквивалентен выражению lanewise(MUL, s, m).

Параметры:

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

результат умножения каждого элемента этого вектора на скалярное значение

См. также:

div

public final ByteVector div(Vector<Byte> v)

Делит этот вектор на второй входной вектор. Это поэлементная бинарная операция, которая применяет примитивную операцию деления (/) к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(DIV, v).

Переопределяет:

div в классе Vector<Byte>

Примечание к API:

Если делитель равен нулю, будет выброшено исключение


ArithmeticException

Параметры:

v — второй входной вектор

Возвращает:

результат деления этого вектора на второй входной вектор

См. также:

div

public final ByteVector div(byte e)

Делит этот вектор на входное скалярное значение, транслируемое во все элементы. Это поэлементная бинарная операция, которая применяет примитивную операцию деления (/) к каждому элементу. Этот метод также эквивалентен выражению lanewise(DIV, e).

Примечание к API:

Если делитель равен нулю, будет выброшено исключение


ArithmeticException

Параметры:

e — входное скалярное значение

Возвращает:

результат деления каждого элемента этого вектора на скалярное значение

См. также:

div

public final ByteVector div(Vector<Byte> v, VectorMask<Byte> m)

Делит этот вектор на второй входной вектор под управлением маски. Это поэлементная бинарная операция, которая применяет примитивную операцию деления (/) к каждой паре соответствующих элементов векторов. Для каждого элемента, не выбранного маской, примитивная операция не выполняется, и этот вектор сохраняет исходное значение, хранящееся в этом элементе. Этот метод также эквивалентен выражению lanewise(DIV, v, m).

Переопределяет:

div в классе Vector<Byte>

Примечание к API:

Если делитель равен нулю, будет выброшено исключение


ArithmeticException

Параметры:

v — второй входной вектор

m — маска, управляющая выбором элементов

Возвращает:

результат деления этого вектора на второй входной вектор

См. также:

div

public final ByteVector div(byte e, VectorMask<Byte> m)

Делит этот вектор на входное скалярное значение, транслируемое во все элементы, выбирая элементы под управлением маски. Это поэлементная бинарная операция с маской, которая применяет примитивную операцию деления (/) к каждому элементу. Этот метод также эквивалентен выражению lanewise(DIV, s, m).

Примечание к API:

Если делитель равен нулю, будет выброшено исключение


ArithmeticException

Параметры:

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

результат деления каждого элемента этого вектора на скалярное значение

См. также:

min

public final ByteVector min(Vector<Byte> v)

Вычисляет минимум этого вектора и второго входного вектора. Это поэлементная бинарная операция, которая применяет операцию Math.min() к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(MIN, v).

Переопределяет:

min в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

поэлементный минимум этого вектора и второго входного вектора

См. также:

min

public final ByteVector min(byte e)

Вычисляет минимум этого вектора и входного скалярного значения, транслируемого во все элементы. Это поэлементная бинарная операция, которая применяет операцию Math.min() к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(MIN, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат умножения этого вектора на заданное скалярное значение

См. также:

max

public final ByteVector max(Vector<Byte> v)

Вычисляет максимум этого вектора и второго входного вектора. Это поэлементная бинарная операция, которая применяет операцию Math.max() к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(MAX, v).

Это не полноценная именованная операция, подобная add(). Версия этой операции с маской напрямую недоступна, но её можно получить с помощью версии lanewise с маской. Подклассы определяют дополнительную перегрузку этого метода с передачей скалярного значения, транслируемого во все элементы.

Переопределяет:

max в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

поэлементный максимум этого вектора и второго входного вектора

См. также:

max

public final ByteVector max(byte e)

Вычисляет максимум этого вектора и входного скалярного значения, транслируемого во все элементы. Это поэлементная бинарная операция, которая применяет операцию Math.max() к каждой паре соответствующих элементов векторов. Этот метод также эквивалентен выражению lanewise(MAX, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат умножения этого вектора на заданное скалярное значение

См. также:

and

public final ByteVector and(Vector<Byte> v)

Вычисляет побитовое логическое И (&) этого вектора и второго входного вектора. Это бинарная операция, выполняемая по элементам, которая применяет примитивную операцию побитового «И» (&) к каждой паре соответствующих значений элементов. Этот метод также эквивалентен выражению lanewise(AND, v).

Это не специализированная именованная операция, такая как add. Версия этой операции с маской недоступна напрямую, но её можно получить с помощью версии lanewise с маской.

Параметры:

v — второй входной вектор

Возвращает:

побитовое & этого вектора и второго входного вектора

См. также:

and

public final ByteVector and(byte e)

Вычисляет побитовое логическое И (&) этого вектора и скалярного значения. Это бинарная операция, выполняемая по элементам, которая применяет примитивную операцию побитового «И» (&) к каждой паре соответствующих значений элементов. Этот метод также эквивалентен выражению lanewise(AND, e).

Параметры:

e — входное скалярное значение

Возвращает:

побитовое & этого вектора и скалярного значения

См. также:

or

public final ByteVector or(Vector<Byte> v)

Вычисляет побитовое логическое ИЛИ (|) этого вектора и второго входного вектора. Это бинарная операция, выполняемая по элементам, которая применяет примитивную операцию побитового «ИЛИ» (|) к каждой паре соответствующих значений элементов. Этот метод также эквивалентен выражению lanewise(AND, v).

Параметры:

v — второй входной вектор

Возвращает:

побитовое | этого вектора и второго входного вектора

См. также:

or

public final ByteVector or(byte e)

Вычисляет побитовое логическое ИЛИ (|) этого вектора и скалярного значения. Это бинарная операция, выполняемая по элементам, которая применяет примитивную операцию побитового «ИЛИ» (|) к каждой паре соответствующих значений элементов. Этот метод также эквивалентен выражению lanewise(OR, e).

Параметры:

e — входное скалярное значение

Возвращает:

побитовое | этого вектора и скалярного значения

См. также:

neg

public final ByteVector neg()

Вычисляет противоположное значение для этого вектора. Это унарная операция, выполняемая по элементам, которая применяет примитивную операцию отрицания (-x) к каждому входному элементу. Этот метод также эквивалентен выражению lanewise(NEG).

Определено в:

neg в классе Vector<Byte>

Возвращает:

противоположное значение этого вектора

См. также:

abs

public final ByteVector abs()

Возвращает абсолютное значение этого вектора. Это унарная операция, выполняемая по элементам, которая применяет метод Math.abs к каждому входному элементу. Этот метод также эквивалентен выражению lanewise(ABS).

Определено в:

abs в классе Vector<Byte>

Возвращает:

абсолютное значение этого вектора

См. также:

not

public final ByteVector not()

Вычисляет побитовое логическое дополнение (~) этого вектора. Это унарная операция, выполняемая по элементам, которая применяет примитивную операцию побитового «НЕ» (~) к каждому значению элемента. Этот метод также эквивалентен выражению lanewise(NOT).

Возвращает:

побитовое дополнение ~ этого вектора

См. также:

eq

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

Проверяет, равен ли этот вектор другому входному вектору. Это бинарная операция проверки, выполняемая по элементам, которая применяет примитивную операцию сравнения на равенство (==) к каждой паре соответствующих значений элементов. Результат совпадает с compare(VectorOperators.EQ, v).

Определено в:

eq в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

результат проверки в виде маски, показывающий для каждого элемента, равен ли этот вектор второму входному вектору

См. также:

eq

public final VectorMask<Byte> eq(byte e)

Проверяет, равен ли этот вектор входному скалярному значению. Это бинарная операция проверки, выполняемая по элементам, которая применяет примитивную операцию сравнения на равенство (==) к каждому элементу. Результат совпадает с compare(VectorOperators.Comparison.EQ, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат проверки в виде маски, показывающий, равен ли этот вектор e

См. также:

lt

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

Проверяет, меньше ли этот вектор другого входного вектора. Это бинарная операция проверки, выполняемая по элементам, которая применяет примитивную операцию сравнения «меньше» (<) к каждому элементу. Результат совпадает с compare(VectorOperators.LT, v).

Определено в:

lt в классе Vector<Byte>

Параметры:

v — второй входной вектор

Возвращает:

результат проверки в виде маски, показывающий для каждого элемента, меньше ли этот вектор второго входного вектора

См. также:

lt

public final VectorMask<Byte> lt(byte e)

Проверяет, меньше ли этот вектор входного скалярного значения. Это бинарная операция проверки, выполняемая по элементам, которая применяет примитивную операцию сравнения «меньше» (<) к каждому элементу. Результат совпадает с compare(VectorOperators.LT, e).

Параметры:

e — входное скалярное значение

Возвращает:

результат проверки в виде маски, показывающий, меньше ли этот вектор входного скалярного значения

См. также:

test

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

Проверяет элементы этого вектора в соответствии с заданной операцией. Это унарная операция проверки, выполняемая по элементам, которая применяет заданную операцию проверки к каждому значению элемента.

Определено в:

test в классе Vector<Byte>

Параметры:

op — операция, используемая для проверки значений элементов

Возвращает:

результат проверки элементов этого вектора в виде маски, согласно выбранному оператору проверки

См. также:

test

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

Проверяет выбранные элементы этого вектора в соответствии с заданной операцией. Это унарная операция проверки с маской, выполняемая по элементам, которая применяет заданную операцию проверки к каждому значению элемента. Возвращаемый результат равен выражению test(op).and(m).

Определено в:

test в классе Vector<Byte>

Параметры:

op — операция, используемая для проверки значений элементов

m — маска, управляющая выбором элементов

Возвращает:

результат проверки элементов этого вектора в виде маски, согласно выбранному оператору проверки и только для элементов, выбранных маской

См. также:

compare

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

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

Определено в:

compare в классе Vector<Byte>

Параметры:

op — операция, используемая для сравнения значений элементов

v — второй входной вектор

Возвращает:

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

См. также:

compare

public abstract VectorMask<Byte> compare(VectorOperators.Comparison op, byte e)

Сравнивает этот вектор с входным скалярным значением в соответствии с заданной операцией сравнения. Это бинарная операция проверки, выполняемая по элементам, которая применяет операцию сравнения к каждому элементу.

Результат совпадает с compare(op, broadcast(species(), e)). Иными словами, можно считать, что скалярное значение распространено на вектор того же вида, после чего оно сравнивается с исходным вектором с использованием выбранной операции сравнения.

Параметры:

op — операция, используемая для сравнения значений элементов

e — входное скалярное значение

Возвращает:

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

См. также:

compare

public final VectorMask<Byte> compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)

Сравнивает этот вектор с входным скалярным значением в соответствии с заданной операцией сравнения для выбранных маской элементов. Это бинарная операция проверки с маской, которая применяется к каждой паре соответствующих значений элементов. Возвращаемый результат равен выражению compare(op,s).and(m).

Параметры:

op — операция, используемая для сравнения значений элементов

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

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

См. также:

compare

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

Сравнивает этот вектор с входным скалярным значением в соответствии с заданной операцией сравнения. Это бинарная операция проверки, выполняемая по элементам, которая применяет заданную операцию сравнения к каждому значению элемента в паре с распространённым значением.

Результат совпадает с this.compare(op, this.broadcast(e)). Иными словами, можно считать, что скалярное значение распространено на вектор того же вида, после чего оно сравнивается с исходным вектором с использованием выбранной операции сравнения.

Определено в:

compare в классе Vector<Byte>

Параметры:

op — операция, используемая для сравнения значений элементов

e — входное скалярное значение

Возвращает:

См. также:

compare

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

Сравнивает этот вектор с входным скалярным значением в соответствии с заданной операцией сравнения для выбранных маской элементов. Это бинарная операция проверки с маской, которая применяет заданную операцию сравнения к каждому значению элемента в паре с распространённым значением. Возвращаемый результат равен выражению compare(op,e).and(m).

Определено в:

compare в классе Vector<Byte>

Параметры:

op — операция, используемая для сравнения значений элементов

e — входное скалярное значение

m — маска, управляющая выбором элементов

Возвращает:

См. также:

blend

public abstract ByteVector blend(Vector<Byte> v, VectorMask<Byte> m)

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

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

Следующий псевдокод иллюстрирует это поведение:

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

Определено в:: blend в классе Vector<Byte>
Параметры:: v — второй входной вектор, содержащий значения элементов для замены; m — маска, управляющая выбором элементов из второго входного вектора
Возвращает:: результат объединения элементов этого вектора с элементами второго входного вектора

addIndex

public abstract ByteVector addIndex(int scale)

Прибавляет к элементам этого вектора соответствующие номера элементов, умноженные на заданную константу. Это унарная операция, выполняемая по элементам: для каждого элемента N вычисляет масштабированное значение индекса N*scale и прибавляет его к значению, уже находящемуся в элементе N текущего вектора.

Масштаб не должен быть слишком большим, а размер элемента — слишком малым, чтобы при вычислении любого из значений N*scale или VLENGTH*scale не возникало переполнения, когда результат представлен типом элементов вектора ETYPE.

Следующий псевдокод иллюстрирует это поведение:

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

Определено в:: addIndex в классе Vector<Byte>
Параметры:: scale — число, на которое умножается индекс каждого элемента N, обычно 1
Возвращает:: результат увеличения значения каждого элемента на соответствующий индекс элемента N, умноженный на scale

blend

public final ByteVector blend(byte e, VectorMask<Byte> m)

Заменяет выбранные элементы этого вектора скалярным значением под управлением маски. Это бинарная операция с маской, выполняемая по элементам, которая выбирает для каждого элемента значение из одного или другого входного значения. Возвращаемый результат равен выражению blend(broadcast(e),m).

Параметры:: e — входное скалярное значение, содержащее значение элемента для замены; m — маска, управляющая выбором скалярного значения для элементов
Возвращает:: результат объединения элементов этого вектора со скалярным значением

blend

public final ByteVector blend(long e, VectorMask<Byte> m)

Определено в:: blend в классе Vector<Byte>
Параметры:: e — входное скалярное значение, содержащее значение элемента для замены; m — маска, управляющая выбором скалярного значения для элементов
Возвращает:: результат объединения элементов этого вектора со скалярным значением

slice

public abstract ByteVector slice(int origin, Vector<Byte> v1)

Извлекает сегмент смежных элементов, начиная с заданного элемента origin текущего вектора и при необходимости продолжая его в непосредственно следующем векторе. Блок из VLENGTH элементов извлекается в отдельный вектор и возвращается.

Это межэлементная операция, которая сдвигает элементы к началу, используя текущий вектор и второй вектор. Оба вектора можно рассматривать как единый «исходный массив» длиной 2*VLENGTH, из которого извлекается срез. Элемент с номером N в выходном векторе копируется из элемента origin+N входного вектора, если такой элемент существует, иначе — из элемента origin+N-VLENGTH второго вектора (который гарантированно существует).

Значение origin должно находиться в диапазоне 0..VLENGTH включительно. В предельных случаях v.slice(0,w) и v.slice(VLENGTH,w) возвращают соответственно v и w.

Параметры:

origin — первый входной элемент, который нужно перенести в срез

v1 — второй вектор, логически присоединяемый к первому перед извлечением среза (если не указан, по умолчанию равен нулю)

Возвращает:

непрерывный срез из VLENGTH элементов, извлечённый из этого вектора начиная с указанной позиции и при необходимости продолжающийся во втором векторе

См. также:

slice

public final ByteVector slice(int origin, Vector<Byte> w, VectorMask<Byte> m)

Извлекает сегмент смежных элементов под управлением маски, начиная с заданного элемента origin текущего вектора и при необходимости продолжая его в непосредственно следующем векторе. Блок из VLENGTH элементов извлекается в отдельный вектор и возвращается. Во всех элементах, сброшенных в заданной маске, результирующий вектор будет содержать нули. Элементы, установленные в маске, будут содержать данные, скопированные из выбранных элементов this или v1.

Определено в:

slice в классе Vector<Byte>

Параметры:

origin — первый входной элемент, который нужно перенести в срез

w — второй вектор, логически присоединяемый к первому перед извлечением среза (если не указан, по умолчанию равен нулю)

m — маска, управляющая выбором элементов результирующего вектора

Возвращает:

См. также:

slice

public abstract ByteVector slice(int origin)

Извлекает сегмент смежных полос, начиная с заданной полосы origin в текущем векторе. Блок из VLENGTH полос, возможно дополненный нулевыми полосами, извлекается в отдельный вектор и возвращается. Это вспомогательный метод, который извлекает данные из одного вектора на фоне, расширенном нулевыми полосами. Он эквивалентен slice


(origin,

broadcast(0)). Его также можно рассматривать просто как сдвиг между полосами от более поздних к более ранним, при котором освободившиеся полосы в конце вектора заполняются нулями. В этом представлении величина сдвига равна origin.

Параметры:

origin — первая входная полоса, переносимая в срез

Возвращает:

последние VLENGTH-origin входных полос, начиная с первой полосы выходных данных и дополненные в конце нулями

См. также:

unslice

public abstract ByteVector unslice(int origin, Vector<Byte> w, int part)

Выполняет обратное действие для slice(), вставляя текущий вектор в качестве среза в другой входной вектор «фона», который рассматривается как один из входных векторов для гипотетической последующей операции slice().

Эта операция между полосами переставляет элементы полос текущего вектора в направлении конца и вставляет их в логическую пару фоновых векторов. Однако возвращается только один из этой пары. Фон формируется дублированием второго входного вектора. (При этом выходные данные никогда не будут содержать два дубликата из одной и той же входной полосы.) Полоса N входного вектора копируется в полосу origin+N первого фонового вектора, если такая полоса существует, иначе — в полосу origin+N-VLENGTH второго фонового вектора (существование которой гарантировано). Возвращается первый или второй фоновый вектор с вставленным срезом. Число part, равное нулю или единице, выбирает первый или второй обновлённый фоновый вектор.

Значение 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.

Определён в:

unslice в классе Vector<Byte>

Параметры:

origin — первая выходная полоса, принимающая срез

w — фоновый вектор, который (в двух копиях) примет вставляемый срез

part — номер части результата (ноль или единица)

Возвращает:

первую или вторую часть пары фоновых векторов w, обновлённую вставкой этого вектора с указанного начала

См. также:

unslice

public abstract ByteVector unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)

Выполняет обратное действие для slice(), вставляя (под управлением маски) текущий вектор в качестве среза в другой входной вектор «фона», который рассматривается как один из входных векторов для гипотетической последующей операции slice().

Эта операция между полосами переставляет элементы полос текущего вектора в направлении начала и вставляет его полосы (если они выбраны маской) в логическую пару фоновых векторов. Как и в версии этого метода без маски, возвращается только один из векторов пары, выбранный числом part. Для каждой полосы N, выбранной маской, значение полосы копируется в полосу origin+N первого фонового вектора, если такая полоса существует, иначе — в полосу origin+N-VLENGTH второго фонового вектора (существование которой гарантировано). Значения фоновых полос сохраняются, если соответствующие входные полосы N не выбраны маской. Возвращается первый или второй фоновый вектор с обновлёнными полосами вставленного среза. Число part, равное нулю или единице, выбирает первый или второй обновлённый фоновый вектор.

Определён в:

unslice в классе Vector<Byte>

Параметры:

origin — первая выходная полоса, принимающая срез

w — фоновый вектор, который (в двух копиях) примет вставляемый срез, если соответствующие полосы выбраны в m

part — номер части результата (ноль или единица)

m — маска, управляющая выбором полос из текущего вектора

Возвращает:

первую или вторую часть пары фоновых векторов w, обновлённую вставкой выбранных полос этого вектора с указанного начала

См. также:

unslice

public abstract ByteVector unslice(int origin)

Выполняет обратное действие для slice(), вставляя текущий вектор в качестве среза во входной «фон» из нулевых значений полос. В отличие от других методов unslice(), этот метод возвращает только первый вектор из пары фоновых векторов. Это вспомогательный метод, возвращающий результат unslice


(origin,

broadcast(0), 0). Его также можно рассматривать просто как сдвиг между полосами от более ранних к более поздним, при котором освободившиеся полосы в начале вектора заполняются нулями. В этом представлении величина сдвига равна origin.

Определён в:

unslice в классе Vector<Byte>

Параметры:

origin — первая выходная полоса, принимающая срез

Возвращает:

первые VLENGTH-origin входных полос, начиная с указанного начала и дополненные в начале нулями

См. также:

rearrange

public abstract ByteVector rearrange(VectorShuffle<Byte> shuffle)

Переставляет элементы полос этого вектора, выбирая полосы под управлением заданной последовательности перестановки. Эта операция между полосами переставляет элементы полос этого вектора. Для каждой полосы N последовательности перестановки и каждого исходного индекса полосы I=s.wrapIndex(s.laneSource(N)) в последовательности перестановки выходная полоса N получает значение из входного вектора в полосе I.

Определён в:

rearrange в классе Vector<Byte>

Параметры:

shuffle — последовательность перестановки, управляющая выбором индексов полос

Возвращает:

перестановку элементов полос этого вектора

См. также:

rearrange

public abstract ByteVector rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)

Переставляет элементы полос этого вектора, выбирая полосы под управлением заданной последовательности перестановки и маски. Эта операция между полосами переставляет элементы полос этого вектора. Для каждой полосы N последовательности перестановки и каждого исходного индекса полосы I=s.wrapIndex(s.laneSource(N)) в последовательности перестановки выходная полоса N получает значение из входного вектора в полосе I, если полоса выбрана маской. В противном случае выходная полоса N устанавливается в ноль.

Этот метод возвращает результат следующего псевдокода:

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

Определён в:

rearrange в классе Vector<Byte>

Параметры:

s — последовательность перестановки, управляющая выбором индексов полос

m — маска, управляющая применением последовательности перестановки

Возвращает:

перестановку элементов полос этого вектора

См. также:

rearrange

public abstract ByteVector rearrange(VectorShuffle<Byte> s, Vector<Byte> v)

Переставляет элементы полос двух векторов, выбирая полосы под управлением заданной последовательности перестановки, используя для выбора данных как обычные, так и исключительные индексы. Эта операция между полосами переставляет элементы полос двух входных векторов (текущего вектора и второго вектора v). Для каждой полосы N последовательности перестановки и каждого исходного индекса полосы I=s.laneSource(N) в последовательности перестановки выходная полоса N получает значение из первого вектора в полосе I, если I>=0. В противном случае исключительный индекс I циклически оборачивается прибавлением VLENGTH и используется для индексации второго вектора по индексу I+VLENGTH.

Этот метод возвращает результат следующего псевдокода:

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

Определён в:

rearrange в классе Vector<Byte>

Параметры:

s — последовательность перестановки, управляющая выбором полос из обоих входных векторов

v — второй входной вектор

Возвращает:

перестановку элементов полос этого и второго входного вектора

См. также:

compress

public abstract ByteVector compress(VectorMask<Byte> m)

Сжимает элементы полос этого вектора, выбирая полосы под управлением заданной маски. Эта операция между полосами сжимает элементы полос этого вектора, выбранные указанной маской. Для каждой полосы N маски, если маска в полосе N установлена, элемент полосы N входного вектора выбирается и помещается в выходной вектор подряд, начиная с полосы 0. Все оставшиеся верхние полосы выходного вектора, если таковые имеются, устанавливаются в ноль.

Определён в:: compress в классе Vector<Byte>
Параметры:: m — маска, управляющая сжатием
Возвращает:: сжатые элементы полос этого вектора
Начиная с:: 19

expand

public abstract ByteVector expand(VectorMask<Byte> m)

Расширяет элементы полос этого вектора под управлением заданной маски. Эта операция между полосами распределяет смежные элементы полос этого вектора по полосам выходного вектора, выбранным указанной маской. Для каждой полосы N маски, если маска в полосе N установлена, следующий смежный элемент входного вектора, начиная с полосы 0, выбирается и помещается в выходной вектор в полосе N. Все оставшиеся полосы выходного вектора, если таковые имеются, устанавливаются в ноль.

Определён в:: expand в классе Vector<Byte>
Параметры:: m — маска, управляющая сжатием
Возвращает:: расширенные элементы полос этого вектора
Начиная с:: 19

selectFrom

public abstract ByteVector selectFrom(Vector<Byte> v)

Используя значения индексов, хранящиеся в полосах этого вектора, собирает значения из второго вектора v. Таким образом, второй вектор служит таблицей, элементы которой выбираются по индексам текущего вектора. Эта операция между полосами переставляет элементы полос вектора-аргумента под управлением этого вектора. Для каждой полосы N этого вектора и каждого значения полосы I=wrapIndex(this.lane(N)) в этом векторе выходная полоса N получает значение из вектора-аргумента в полосе I. Таким образом, результат содержит только значения, хранящиеся в векторе-аргументе v, но расположенные в порядке, зависящем от значений индексов в this. Результат совпадает с выражением v.rearrange(this.toShuffle()).

Определён в:

selectFrom в классе Vector<Byte>

Параметры:

v — вектор, предоставляющий значения результата

Возвращает:

перестановку элементов полос v

См. также:

selectFrom

public abstract ByteVector selectFrom(Vector<Byte> s, VectorMask<Byte> m)

Используя значения индексов, хранящиеся в полосах этого вектора, собирает значения из второго вектора под управлением маски. Используя значения индексов, хранящиеся в полосах этого вектора, собирает значения из второго вектора v. Таким образом, второй вектор служит таблицей, элементы которой выбираются по индексам текущего вектора. Полосы, не выбранные маской, получают ноль, а не значение из таблицы. Эта операция между полосами переставляет элементы полос вектора-аргумента под управлением этого вектора и маски. Результат совпадает с выражением v.rearrange(this.toShuffle(), m).

Определён в:

selectFrom в классе Vector<Byte>

Параметры:

s — вектор, предоставляющий значения результата

m — маска, управляющая выбором из v

Возвращает:

перестановку элементов полос v

См. также:

selectFrom

public abstract ByteVector selectFrom(Vector<Byte> v1, Vector<Byte> v2)

Используя значения, хранящиеся в полосах этого вектора, собирает значения из второго вектора v1 и третьего вектора v2. Таким образом, второй и третий векторы служат таблицей, элементы которой выбираются по индексам этого вектора. Эта операция между полосами переставляет элементы полос векторов-аргументов под управлением этого вектора. Для каждой полосы N этого вектора и каждого значения полосы I=wrapIndex(this.lane(N) в этом векторе выходная полоса N получает значение из второго вектора в полосе I, если I < VLENGTH. В противном случае выходная полоса N получает значение из третьего вектора в полосе I - VLENGTH. Здесь VLENGTH — результат this.length(), а для целочисленных значений wrapIndex вычисляет результат Math.floorMod(E, 2 * VLENGTH), где E — индекс, который необходимо обернуть. Если VLENGTH является степенью двойки, результат также равен 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 является степенью двойки. Поэлементная операция AND даёт вектор, элементы которого находятся в диапазоне [0, 2 * VLENGTH - 1]). Преобразование в последовательность перестановки даёт частично обёрнутую последовательность, индексы которой находятся в диапазоне [-VLENGTH, VLENGTH - 1]), где для выбора элементов третьего вектора используются исключительные индексы.

Определён в:

selectFrom в классе Vector<Byte>

Параметры:

v1 — первый входной вектор

v2 — второй входной вектор

Возвращает:

перестановку элементов полос v1 и v2

См. также:

bitwiseBlend

public final ByteVector bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)

Смешивает биты двух векторов под управлением третьего вектора, предоставляющего биты маски. Эта поэлементная тернарная операция выполняет побитовое смешивание (a&~c)|(b&c) для каждой полосы. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits — входные биты, смешиваемые с текущим вектором

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

побитовое смешивание заданных битов с текущим вектором под управлением побитовой маски

См. также:

bitwiseBlend

public final ByteVector bitwiseBlend(byte bits, byte mask)

Смешивает биты вектора и скалярного значения под управлением другого скалярного значения, предоставляющего биты маски. Эта поэлементная тернарная операция выполняет побитовое смешивание (a&~c)|(b&c) для каждой полосы. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits — входные биты, смешиваемые с текущим вектором

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

побитовое смешивание заданных битов с текущим вектором под управлением побитовой маски

См. также:

bitwiseBlend

public final ByteVector bitwiseBlend(byte bits, Vector<Byte> mask)

Смешивает биты вектора и скалярного значения под управлением другого вектора, предоставляющего биты маски. Эта поэлементная тернарная операция выполняет побитовое смешивание (a&~c)|(b&c) для каждой полосы. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits — входные биты, смешиваемые с текущим вектором

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

побитовое смешивание заданных битов с текущим вектором под управлением побитовой маски

См. также:

bitwiseBlend

public final ByteVector bitwiseBlend(Vector<Byte> bits, byte mask)

Смешивает биты двух векторов под управлением скалярного значения, предоставляющего биты маски. Эта поэлементная тернарная операция выполняет побитовое смешивание (a&~c)|(b&c) для каждой полосы. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits — входные биты, смешиваемые с текущим вектором

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

побитовое смешивание заданных битов с текущим вектором под управлением побитовой маски

См. также:

reduceLanes

public abstract byte reduceLanes(VectorOperators.Associative op)

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

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

В случае FIRST_NONZERO свёртка возвращает значение из полосы с наименьшим номером, содержащей ненулевое значение.
Все остальные операции свёртки являются полностью коммутативными и ассоциативными. Реализация может выбрать любой порядок обработки, но результат всегда будет одинаковым.

Параметры:

op — операция, используемая для объединения значений полос

Возвращает:

накопленный результат

Выбрасывает:

UnsupportedOperationException — если этот вектор не поддерживает запрошенную операцию

См. также:

reduceLanes

public abstract byte reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)

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

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

Если операция — ADD, XOR, OR или FIRST_NONZERO, нейтральным значением является ноль, значение byte по умолчанию.
Если операция — MUL, нейтральным значением является единица.
Если операция — AND, нейтральным значением является минус один (все биты установлены).
Если операция — MAX, нейтральным значением является Byte.MIN_VALUE.
Если операция — MIN, нейтральным значением является Byte.MAX_VALUE.

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

В случае FIRST_NONZERO редукция возвращает значение из полосы с наименьшим номером, содержащей ненулевое значение.
Все остальные операции редукции являются полностью коммутативными и ассоциативными. Реализация может выбрать любой порядок обработки, но результат всегда будет одинаковым.

Параметры:

op - операция, используемая для объединения значений полос

m - маска, управляющая выбором полос

Возвращает:

результат редукции, полученный накоплением значений выбранных полос

Исключения:

UnsupportedOperationException - если этот вектор не поддерживает запрошенную операцию

См. также:

lane

public abstract byte lane(int i)

Возвращает элемент полосы с индексом i

Параметры:: i - индекс полосы
Возвращает:: элемент полосы с индексом i
Исключения:: IllegalArgumentException - если индекс выходит за допустимый диапазон (< 0 || >= length())

withLane

public abstract ByteVector withLane(int i, byte e)

Заменяет элемент полосы этого вектора с индексом i значением e. Это операция между полосами; она действует так, как если бы возвращала результат смешивания этого вектора с входным вектором, полученным широковещательной передачей e, и маской, в которой установлена только одна полоса с индексом i.

Параметры:: i - индекс заменяемого элемента полосы; e - устанавливаемое значение
Возвращает:: результат замены элемента полосы этого вектора с индексом i значением e.
Исключения:: IllegalArgumentException - если индекс выходит за допустимый диапазон (< 0 || >= length())

toArray

public final byte[] toArray()

Возвращает массив типа byte[], содержащий все значения полос. Длина массива совпадает с длиной вектора. Элементы массива располагаются в порядке полос.

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

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

Определено в:

toArray в классе Vector<Byte>

Возвращает:

массив, содержащий значения полос этого вектора

См. также:

toIntArray

public final int[] toIntArray()

Возвращает массив int[], содержащий все значения полос, преобразованные в тип int. Длина массива совпадает с длиной вектора. Элементы массива преобразуются, как при приведении типов, и сохраняются в порядке полос. Эта операция может завершиться неудачей, если тип элементов вектора —


float

или double, а полосы содержат дробные значения или значения вне допустимого диапазона. Если какое-либо значение полосы вектора нельзя представить в виде int, выбрасывается исключение.

Определено в:

toIntArray в классе Vector<Byte>

Примечание по реализации:

При использовании этого метода для векторов типа ByteVector потери точности или диапазона не происходит, поэтому UnsupportedOperationException не будет выброшено.

Возвращает:

массив int[], содержащий значения полос этого вектора

См. также:

toLongArray

public final long[] toLongArray()

Возвращает массив long[], содержащий все значения полос, преобразованные в тип long. Длина массива совпадает с длиной вектора. Элементы массива преобразуются, как при приведении типов, и сохраняются в порядке полос. Эта операция может завершиться неудачей, если тип элементов вектора —


float

или double, а полосы содержат дробные значения или значения вне допустимого диапазона. Если какое-либо значение полосы вектора нельзя представить в виде long, выбрасывается исключение.

Определено в:

toLongArray в классе Vector<Byte>

Примечание по реализации:

Возвращает:

массив long[], содержащий значения полос этого вектора

См. также:

toDoubleArray

public final double[] toDoubleArray()

Возвращает массив double[], содержащий все значения полос, преобразованные в тип double. Длина массива совпадает с длиной вектора. Элементы массива преобразуются, как при приведении типов, и сохраняются в порядке полос. Эта операция может привести к потере точности, если тип элементов вектора — long.

Определено в:

toDoubleArray в классе Vector<Byte>

Примечание по реализации:

При использовании этого метода для векторов типа ByteVector потери точности не происходит.

Возвращает:

массив double[], содержащий значения полос этого вектора, которые могут быть округлены до представимых значений double

См. также:

fromArray

public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset)

Загружает вектор из массива типа byte[], начиная с заданного смещения. Для каждой полосы вектора, где N — индекс полосы вектора, элемент массива с индексом offset + N помещается в результирующий вектор в полосу с индексом N.

Параметры:: species - вид требуемого вектора; a - массив; offset - смещение в массиве
Возвращает:: вектор, загруженный из массива
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора

fromArray

public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)

Загружает вектор из массива типа byte[], начиная с заданного смещения и используя маску. Полосы, не выбранные маской, заполняются значением типа byte по умолчанию (нулём). Для каждой полосы вектора, где N — индекс полосы вектора, если полоса маски с индексом N установлена, то элемент массива с индексом offset + N помещается в результирующий вектор в полосу с индексом N; в противном случае в полосу результирующего вектора с индексом N помещается значение элемента по умолчанию.

Параметры:: species - вид требуемого вектора; a - массив; offset - смещение в массиве; m - маска, управляющая выбором полос
Возвращает:: вектор, загруженный из массива
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора, выбранной маской

fromArray

public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)

Собирает новый вектор из элементов массива типа byte[], используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, полоса загружается из элемента массива a[f(N)], где f(N) — выражение отображения индекса offset + indexMap[mapOffset + N]].

Параметры:

species - вид требуемого вектора

a - массив

offset - смещение в массиве; может быть отрицательным, если относительные индексы в карте индексов компенсируют его и дают значение в пределах массива

indexMap - карта индексов

mapOffset - смещение в карте индексов

Возвращает:

вектор, загруженный из индексированных элементов массива

Исключения:

IndexOutOfBoundsException - если mapOffset+N < 0 или если mapOffset+N >= indexMap.length, или если f(N)=offset+indexMap[mapOffset+N] является недопустимым индексом в a для любой полосы N вектора

См. также:

fromArray

public static ByteVector fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)

Собирает новый вектор из элементов массива типа byte[] под управлением маски, используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, если полоса установлена в маске, она загружается из элемента массива a[f(N)], где f(N) — выражение отображения индекса offset + indexMap[mapOffset + N]]. Неустановленные полосы результирующего вектора заполняются нулями.

Параметры:

species - вид требуемого вектора

a - массив

indexMap - карта индексов

mapOffset - смещение в карте индексов

m - маска, управляющая выбором полос

Возвращает:

вектор, загруженный из индексированных элементов массива

Исключения:

См. также:

fromBooleanArray

public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset)

Загружает вектор из массива типа boolean[], начиная с заданного смещения. Для каждой полосы вектора, где N — индекс полосы вектора, элемент массива с индексом offset + N сначала преобразуется в значение типа byte, а затем помещается в результирующий вектор в полосу с индексом N.

Значение типа boolean преобразуется в значение типа byte с помощью выражения (byte) (b ? 1 : 0), где b — значение типа boolean.

Параметры:: species - вид требуемого вектора; a - массив; offset - смещение в массиве
Возвращает:: вектор, загруженный из массива
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора

fromBooleanArray

public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)

Загружает вектор из массива типа boolean[], начиная с заданного смещения и используя маску. Полосы, не выбранные маской, заполняются значением типа byte по умолчанию (нулём). Для каждой полосы вектора, где N — индекс полосы вектора, если полоса маски с индексом N установлена, то элемент массива с индексом offset + N сначала преобразуется в значение типа byte, а затем помещается в результирующий вектор в полосу с индексом N; в противном случае в полосу результирующего вектора с индексом N помещается значение элемента по умолчанию.

Параметры:: species - вид требуемого вектора; a - массив; offset - смещение в массиве; m - маска, управляющая выбором полос
Возвращает:: вектор, загруженный из массива
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора, выбранной маской

fromBooleanArray

public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset)

Собирает новый вектор из элементов массива типа boolean[], используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, полоса загружается из выражения (byte) (a[f(N)] ? 1 : 0), где f(N) — выражение отображения индекса offset + indexMap[mapOffset + N]].

Параметры:

species - вид требуемого вектора

a - массив

indexMap - карта индексов

mapOffset - смещение в карте индексов

Возвращает:

вектор, загруженный из индексированных элементов массива

Исключения:

См. также:

fromBooleanArray

public static ByteVector fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)

Собирает новый вектор из элементов массива типа boolean[] под управлением маски, используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, если полоса установлена в маске, она загружается из выражения (byte) (a[f(N)] ? 1 : 0), где f(N) — выражение отображения индекса offset + indexMap[mapOffset + N]]. Неустановленные полосы результирующего вектора заполняются нулями.

Параметры:

species - вид требуемого вектора

a - массив

indexMap - карта индексов

mapOffset - смещение в карте индексов

m - маска, управляющая выбором полос

Возвращает:

вектор, загруженный из индексированных элементов массива

Исключения:

См. также:

fromMemorySegment

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

Загружает вектор из сегмента памяти, начиная со смещения в сегменте памяти. Байты объединяются в примитивные элементы полос в соответствии с заданным порядком байтов. Полосы вектора располагаются согласно порядку байтов в памяти.

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

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

Параметры:: species - вид требуемого вектора; ms - сегмент памяти; offset - смещение в сегменте памяти; bo - требуемый порядок байтов
Возвращает:: вектор, загруженный из сегмента памяти
Исключения:: IndexOutOfBoundsException - если offset+N*1 < 0 или offset+N*1 >= ms.byteSize() для любой полосы N вектора; IllegalStateException - если сеанс сегмента памяти неактивен или доступ выполняется из потока, отличного от потока, которому принадлежит сеанс.
Начиная с:: 19

fromMemorySegment

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

Загружает вектор из сегмента памяти, начиная со смещения в сегменте памяти и используя маску. Полосы, не выбранные маской, заполняются значением типа byte по умолчанию (нулём). Байты объединяются в примитивные элементы полос в соответствии с заданным порядком байтов. Полосы вектора располагаются согласно порядку байтов в памяти.

Следующий псевдокод иллюстрирует поведение:

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

Примечание по реализации:: Аргумент порядка байтов игнорируется.
Параметры:: species - вид требуемого вектора; ms - сегмент памяти; offset - смещение в сегменте памяти; bo - требуемый порядок байтов; m - маска, управляющая выбором полос
Возвращает:: вектор, загруженный из сегмента памяти
Исключения:: IndexOutOfBoundsException - если offset+N*1 < 0 или offset+N*1 >= ms.byteSize() для любой полосы N вектора, выбранной маской; IllegalStateException - если сеанс сегмента памяти неактивен или доступ выполняется из потока, отличного от потока, которому принадлежит сеанс.
Начиная с:: 19

intoArray

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

Сохраняет этот вектор в массиве типа byte[], начиная с заданного смещения.

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

Параметры:: a - массив типа byte[]; offset - смещение в массиве
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора

intoArray

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

Сохраняет этот вектор в массиве типа byte[], начиная с заданного смещения и используя маску.

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

Проверка границ массива выполняется для полос, выбранных маской. Неустановленные маской полосы не сохраняются и не должны соответствовать допустимым элементам a. То есть неустановленным полосам могут соответствовать индексы массива меньше нуля или выходящие за его конец.

Параметры:: a - массив типа byte[]; offset - смещение в массиве; m - маска, управляющая сохранением полос
Исключения:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любой полосы N вектора, выбранной маской

intoArray

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

Распределяет элементы этого вектора по массиву типа byte[], используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

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

Параметры:

a - массив

offset - смещение, складываемое со смещениями карты индексов

indexMap - карта индексов

mapOffset - смещение в карте индексов

Исключения:

См. также:

intoArray

public final void intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)

Распределяет элементы этого вектора по массиву типа byte[] под управлением маски, используя индексы, полученные добавлением фиксированного значения offset к последовательности дополнительных смещений из карты индексов. Карта индексов представляет собой непрерывную последовательность из VLENGTH элементов во втором массиве типа int, начиная с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, если полоса маски с индексом N установлена, элемент полосы с индексом N сохраняется в элемент массива a[f(N)], где f(N) — выражение отображения индекса offset + indexMap[mapOffset + N]].

Параметры:

a - массив

offset - смещение, складываемое со смещениями карты индексов

indexMap - карта индексов

mapOffset - смещение в карте индексов

m - маска

Исключения:

См. также:

intoBooleanArray

public final void intoBooleanArray(boolean[] a, int offset)

Сохраняет этот вектор в массив типа boolean[], начиная с заданного смещения.

Значение типа byte преобразуется в значение типа boolean путем применения выражения (b & 1) != 0, где b — значение байта.

Параметры:: a — массив; offset — смещение в массиве
Исключения:: IndexOutOfBoundsException — если offset+N < 0 или offset+N >= a.length для любой полосы N вектора

intoBooleanArray

public final void intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m)

Сохраняет этот вектор в массив типа boolean[], начиная с заданного смещения и используя маску.

Для каждой полосы вектора, где N — индекс полосы вектора, элемент полосы с индексом N сначала преобразуется в значение типа boolean, а затем сохраняется в элемент массива a[offset+N]. Если полоса маски в позиции N не установлена, соответствующий элемент массива a[offset+N] остается без изменений.

Проверка диапазона массива выполняется для полос, для которых установлена маска. Неустановленные полосы не сохраняются и не должны соответствовать допустимым элементам a. То есть неустановленные полосы могут соответствовать индексам массива меньше нуля или выходящим за пределы массива.

Параметры:: a — массив; offset — смещение в массиве; m — маска, управляющая сохранением полос
Исключения:: IndexOutOfBoundsException — если offset+N < 0 или offset+N >= a.length для любой полосы N вектора, для которой установлена маска

intoBooleanArray

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

Распределяет элементы этого вектора по массиву типа boolean[], используя индексы, полученные путем сложения фиксированного offset с последовательностью дополнительных смещений из карты индексов. Карта индексов — это непрерывная последовательность элементов VLENGTH во втором массиве типа int, начинающаяся с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, элемент полосы с индексом N сначала преобразуется в значение типа boolean, а затем сохраняется в элемент массива a[f(N)], где f(N) — выражение отображения индексов offset + indexMap[mapOffset + N]].

Параметры:

a — массив

offset — смещение, которое нужно сложить со смещениями из карты индексов

indexMap — карта индексов

mapOffset — смещение в карте индексов

Исключения:

IndexOutOfBoundsException — если mapOffset+N < 0 или если mapOffset+N >= indexMap.length, либо если f(N)=offset+indexMap[mapOffset+N] является недопустимым индексом в a для любой полосы N вектора

См. также:

intoBooleanArray

public final void intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)

Распределяет элементы этого вектора по массиву типа boolean[] под управлением маски, используя индексы, полученные путем сложения фиксированного offset с последовательностью дополнительных смещений из карты индексов. Карта индексов — это непрерывная последовательность элементов VLENGTH во втором массиве типа int, начинающаяся с заданного mapOffset.

Для каждой полосы вектора, где N — индекс полосы вектора, если полоса маски с индексом N установлена, элемент полосы с индексом N сначала преобразуется в значение типа boolean, а затем сохраняется в элемент массива a[f(N)], где f(N) — выражение отображения индексов offset + indexMap[mapOffset + N]].

Параметры:

a — массив

offset — смещение, которое нужно сложить со смещениями из карты индексов

indexMap — карта индексов

mapOffset — смещение в карте индексов

m — маска

Исключения:

См. также:

intoMemorySegment

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

Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения и используя явный порядок байтов.

Байты извлекаются из примитивных элементов полос в соответствии с указанным порядком байтов. Полосы сохраняются в соответствии с их порядком в памяти.

Этот метод работает так, как если бы он вызывал intoMemorySegment() следующим образом:

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

Определено в:: intoMemorySegment в классе Vector<Byte>
Параметры:: ms — сегмент памяти; offset — смещение в сегменте памяти; bo — требуемый порядок байтов
Начиная с:: 19

intoMemorySegment

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

Определено в:: intoMemorySegment в классе Vector<Byte>
Параметры:: ms — сегмент памяти; offset — смещение в сегменте памяти; bo — требуемый порядок байтов; m — маска, управляющая выбором полос
Начиная с:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

Представляет этот вектор как вектор той же формы и с тем же содержимым, но с типом полос byte, извлекая байты из полос в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(byte.class)). Его можно считать обратным к различным методам, объединяющим байты в более широкие полосы внутри того же вектора, например Vector.reinterpretAsInts().

Определено в:

reinterpretAsBytes в классе Vector<Byte>

Возвращает:

ByteVector той же формы и с тем же информационным содержимым

См. также:

viewAsIntegralLanes

public final ByteVector viewAsIntegralLanes()

Представляет этот вектор как вектор той же формы, длины и с тем же содержимым, но с типом полос, не являющимся типом с плавающей точкой. Это переинтерпретирующее приведение значений полос выполняется поэлементно. Поэтому этот метод не изменяет VSHAPE или VLENGTH, и побитовое содержимое вектора остается неизменным. Если ETYPE вектора уже является целочисленным типом, возвращается тот же вектор без изменений. Этот метод возвращает значение выражения convert(conv,0), где conv — это VectorOperators.Conversion.ofReinterpret(E.class,F.class), а F — тип без плавающей точки того же размера, что и E.

Определено в:

viewAsIntegralLanes в классе Vector<Byte>

Возвращает:

исходный вектор, переинтерпретированный как вектор с типом без плавающей точки

См. также:

viewAsFloatingLanes

public final Vector<?> viewAsFloatingLanes()

Представляет этот вектор как вектор той же формы, длины и с тем же содержимым, но с типом полос, являющимся типом с плавающей точкой. Это переинтерпретирующее приведение значений полос выполняется поэлементно. Поэтому этот метод не изменяет VSHAPE или VLENGTH, и побитовое содержимое вектора остается неизменным. Если ETYPE вектора уже является типом с плавающей точкой, возвращается тот же вектор без изменений. Если размер элемента вектора не соответствует размеру ни одного типа с плавающей точкой, выбрасывается исключение IllegalArgumentException. Этот метод возвращает значение выражения convert(conv,0), где conv — это VectorOperators.Conversion.ofReinterpret(E.class,F.class), а F — тип с плавающей точкой того же размера, что и E, если такой тип существует.

Определено в:

viewAsFloatingLanes в классе Vector<Byte>

Примечание по реализации:

Этот метод всегда выбрасывает UnsupportedOperationException, поскольку не существует типа с плавающей точкой того же размера, что и byte. Тип возвращаемого значения этого метода выбран произвольно как Vector<?>. В будущих версиях этого API тип возвращаемого значения может измениться, если станут доступны дополнительные типы с плавающей точкой.

Возвращает:

исходный вектор, переинтерпретированный как вектор с плавающей точкой

См. также:

toString

public final String toString()

Возвращает строковое представление этого вектора вида "[0,1,2...]", содержащее значения полос этого вектора в порядке следования полос. Строка формируется так, как если бы был вызван метод Arrays.toString(), соответствующий массиву типа byte, возвращаемому методом this.toArray().

Определено в:: toString в классе Vector<Byte>
Возвращает:: строку вида "[0,1,2...]", содержащую значения полос этого вектора

equals

public final boolean equals(Object obj)

Указывает, идентичен ли этот вектор некоторому другому объекту. Два вектора идентичны, только если у них одинаковые виды и одинаковые значения полос в том же порядке.

Сравнение значений полос выполняется так, как если бы был вызван метод Arrays.equals(), соответствующий массивам, возвращаемым методом toArray() для обоих векторов.

Определено в:

equals в классе Vector<Byte>

Параметры:

obj — объект-ссылка, с которым выполняется сравнение.

Возвращает:

указывает ли значение на идентичность этого вектора некоторому другому объекту

См. также:

hashCode

public final int hashCode()

Возвращает хеш-код вектора, основанный на значениях полос и виде вектора.

Определено в:

hashCode в классе Vector<Byte>

Возвращает:

хеш-код этого вектора

См. также:

species

public final VectorSpecies<Byte> species()

Описание скопировано из класса: Vector

Возвращает вид этого вектора.

Определено в:: species в классе Vector<E>
Возвращает:: вид этого вектора

check

public final <F> Vector<F> check(VectorSpecies<F> species)

Описание скопировано из класса: Vector

Проверяет, что этот вектор имеет заданный вид, и возвращает его без изменений. Действие аналогично следующему псевдокоду:

species == species()
       ? this
       : throw new ClassCastException()

Определено в:

check в классе Vector<E>

Параметры типа:

F — упакованный тип элемента требуемого вида

Параметры:

species — требуемый вид

Возвращает:

тот же вектор

См. также:

check

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

Проверяет, что этот вектор имеет заданный тип элемента, и возвращает его без изменений. Действие аналогично следующему псевдокоду:

elementType == species().elementType()
       ? this
       : throw new ClassCastException()

Определено в:

check в классе Vector<E>

Параметры типа:

F — упакованный тип элемента требуемого типа полосы

Параметры:

elementType — требуемый тип полосы

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Byte> maskAll(boolean bit)

Возвращает маску того же вида, что и этот вектор, в которой каждая полоса установлена или не установлена в соответствии с заданным одиночным логическим значением, распространяемым на все полосы.

Этот метод возвращает значение выражения species().maskAll(bit).

Определено в:

maskAll в классе Vector<E>

Параметры:

bit — заданный бит маски для копирования

Возвращает:

маску, в которой каждая полоса установлена или не установлена в соответствии с заданным битом

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос short; полосы формируются из последовательных байтов в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(short.class)). Его можно считать обратным к Vector.reinterpretAsBytes().

Определено в:: reinterpretAsShorts в классе Vector<E>
Возвращает:: ShortVector той же формы и с тем же информационным содержимым

reinterpretAsInts

public IntVector reinterpretAsInts()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос int; полосы формируются из последовательных байтов в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(int.class)). Его можно считать обратным к Vector.reinterpretAsBytes().

Определено в:: reinterpretAsInts в классе Vector<E>
Возвращает:: IntVector той же формы и с тем же информационным содержимым

reinterpretAsLongs

public LongVector reinterpretAsLongs()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос long; полосы формируются из последовательных байтов в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(long.class)). Его можно считать обратным к Vector.reinterpretAsBytes().

Определено в:: reinterpretAsLongs в классе Vector<E>
Возвращает:: LongVector той же формы и с тем же информационным содержимым

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос float; полосы формируются из последовательных байтов в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(float.class)). Его можно считать обратным к Vector.reinterpretAsBytes().

Определено в:: reinterpretAsFloats в классе Vector<E>
Возвращает:: FloatVector той же формы и с тем же информационным содержимым

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос double; полосы формируются из последовательных байтов в порядке от младшего к старшему. Это удобный метод для выражения reinterpretShape(species().withLanes(double.class)). Его можно считать обратным к Vector.reinterpretAsBytes().

Определено в:: reinterpretAsDoubles в классе Vector<E>
Возвращает:: DoubleVector той же формы и с тем же информационным содержимым

convert

public final <F> Vector<F> convert(VectorOperators.Conversion<Byte,F> conv, int part)

Преобразует этот вектор в вектор той же формы и с новым типом элементов, преобразуя значения элементов из текущего ETYPE в новый тип элементов (далее — FTYPE) согласно указанному преобразованию. Это операция, выполняемая поэлементно и не меняющая форму, которая копирует значения ETYPE из входного вектора в соответствующие значения FTYPE результата. В зависимости от выбранного преобразования эта операция может либо расширять или сужать свой логический результат; в этом случае ненулевое число part может дополнительно управлять выбором и направлением логического результата в физический выходной вектор.

Каждое конкретное преобразование описывается константой преобразования в классе VectorOperators. Для каждого оператора преобразования заданы тип области определения и тип области значений. Тип области определения должен точно совпадать с типом элементов входного вектора, а тип области значений определяет тип элементов выходных векторов.

Оператор преобразования можно классифицировать как (соответственно) выполняющий преобразование на месте, расширяющий или сужающий — в зависимости от того, равен ли (соответственно), меньше или больше размер в битах типа области определения размера в битах типа области значений.

Независимо от этого операции преобразования также можно классифицировать как переинтерпретирующие или преобразующие значения — в зависимости от того, копирует ли преобразование биты представления без изменений или изменяет их, чтобы сохранить (часть или всё) логическое значение входного значения.

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

Расширяющее преобразование, такое как S2I (значение short в int), принимает скалярное значение и представляет его в более широком формате (всегда с некоторой избыточностью информации). Сужающее преобразование, такое как D2F (значение double в float), принимает скалярное значение и представляет его в более узком формате (всегда с некоторой потерей информации). Некоторые преобразования на месте также могут сопровождаться потерей информации, например L2D (значение long в double) или F2I (значение float в int). Переинтерпретирующие преобразования на месте не приводят к потере данных, если только побитовое значение каким-либо образом не является допустимым для выходного типа. Преобразование битового шаблона NaN может отбросить биты мантиссы значения NaN.

Эта классификация важна, поскольку, если не указано иное, операции преобразования никогда не меняют форму вектора, независимо от того, как они могут менять размеры элементов. Поэтому расширяющее преобразование не может сохранить все результаты в выходном векторе, поскольку в выходном векторе меньше элементов большего размера, чтобы его общий размер в битах совпадал с размером входного вектора. Аналогично, сужающее преобразование должно поместить сравнительно небольшие результаты в подмножество элементов выходного вектора, а неиспользуемые элементы по умолчанию заполнить нулями.

Например, преобразование из byte в long (M=8) отбросит 87,5 % входных значений, чтобы преобразовать оставшиеся 12,5 % в просторные элементы long выходного вектора. Обратное преобразование преобразует обратно все большие результаты, но при этом 87,5 % элементов выходного вектора останутся неиспользованными. Преобразования на месте (M=1) помещают все результаты в один выходной вектор, не оставляя неиспользованных элементов.

Чтобы управлять деталями этих расширений и сужений, ненулевой параметр part выбирает частичные результаты расширений или направляет результаты сужений в соответствующие позиции следующим образом:

расширение в M раз: part должно находиться в диапазоне [0..M-1] и выбирает блок из VLENGTH/M входных элементов, начинающийся с начального элемента part*VLENGTH/M.
VLENGTH/M выходных элементов представляют собой частичный фрагмент полного логического результата преобразования, заполняющий весь физический выходной вектор.
сужение в M раз: part должно находиться в диапазоне [-M+1..0]; оно направляет все VLENGTH входных элементов в выходные данные, начиная с начального элемента -part*VLENGTH. Всего имеется VLENGTH*M выходных элементов, а элементы, не содержащие преобразованных входных значений, заполняются нулями.
Группу таких выходных векторов, в которых части логического результата направлены в непересекающиеся блоки, можно объединить с помощью оператора побитового ИЛИ или (для чисел с плавающей запятой) оператора FIRST_NONZERO.
преобразование на месте (M=1): part должно быть равно нулю. Оба вектора имеют одинаковый VLENGTH. Результат всегда располагается с нулевого начального элемента.

Этот метод представляет собой ограниченную версию более общего, но используемого реже метода изменения формы convertShape(). Результат этого метода совпадает с результатом выражения this.convertShape(conv, rsp, this.broadcast(part)), где выходной вид вектора — rsp=this.species().withLanes(FTYPE.class).

Определено в:

convert в классе Vector<E>

Параметры типа:

F — упакованный тип элемента вида вектора

Параметры:

conv — требуемое скалярное преобразование, применяемое к каждому элементу

part — номер части результата или ноль, если преобразование не является ни расширяющим, ни сужающим

Возвращает:

вектор, преобразованный из этого вектора по форме и типу элементов

См. также:

castShape

public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)

Вспомогательный метод для преобразования вектора из одного типа элементов в другой с изменением формы при необходимости, если размеры элементов различаются. Этот метод возвращает значение выражения: convertShape(conv,rsp,part), где conv — это VectorOperators.Conversion.ofCast(E.class,F.class).

Если старый и новый виды вектора имеют разную форму, это операция изменения формы, которая может иметь особые издержки реализации.

Определено в:

castShape в классе Vector<E>

Параметры типа:

F — упакованный тип элемента выходного вида вектора

Параметры:

toSpecies — требуемый выходной вид вектора

part — номер части результата или ноль, если преобразование не является ни расширяющим, ни сужающим

Возвращает:

вектор, преобразованный из этого вектора по типу элементов

См. также:

convertShape

public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Byte,F> conv, VectorSpecies<F> rsp, int part)

Преобразует этот вектор в вектор заданного вида, формы и типа элементов, преобразуя значения элементов из текущего ETYPE в новый тип элементов (далее — FTYPE) согласно указанному преобразованию. Это поэлементная операция, которая копирует значения ETYPE из входного вектора в соответствующие значения FTYPE результата.

Если старый и новый виды вектора имеют одинаковую форму, поведение полностью совпадает с поведением более простого метода, не меняющего форму: convert(). В таких случаях следует использовать более простой метод convert(), чтобы упростить анализ кода. В противном случае это операция изменения формы, которая может иметь особые издержки реализации.

Совместное изменение формы и размера элементов может привести к тому, что входной и выходной виды вектора будут иметь разное число элементов, вызывая расширение или сужение. В этом случае ненулевой параметр part выбирает частичные результаты расширенного логического результата или направляет результаты суженного логического результата в физический выходной вектор требуемого выходного вида.

Следующий псевдокод иллюстрирует поведение этого метода при преобразованиях на месте, расширяющих и сужающих преобразованиях. (Этот псевдокод также применим к методу, не меняющему форму, но с ограничениями на форму выходного вида вектора.) Обратите внимание: для любой конкретной комбинации оператора преобразования и форм применим только один из трёх путей выполнения.

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

Определено в:

convertShape в классе Vector<E>

Параметры типа:

F — упакованный тип элемента выходного вида вектора

Параметры:

conv — требуемое скалярное преобразование, применяемое к каждому элементу

rsp — требуемый выходной вид вектора

part — номер части результата или ноль, если преобразование не является ни расширяющим, ни сужающим

Возвращает:

вектор, преобразованный из этого вектора по типу элементов

См. также:

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://docs.oracle.com/en/java/javase/25/docs/api/jdk.incubator.vector/jdk/incubator/vector/ByteVector.html