Класс ByteVector

java.lang.Object

jdk.incubator.vector.Vector<Byte>

jdk.incubator.vector.ByteVector

public abstract sealed 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

Модификатор и тип	Метод	Описание
`abstract int`	`bitSize()`	Возвращает общий размер этого вектора в битах.
`abstract int`	`byteSize()`	Возвращает общий размер этого вектора в байтах.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)`	Проверяет этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения для элементов, выбранных маской.
`abstract int`	`elementSize()`	Возвращает размер каждого элемента этого вектора в битах.
`abstract Class<Byte>`	`elementType()`	Возвращает примитивный тип элемента (`ETYPE`) этого вектора.
`abstract int`	`length()`	Возвращает количество элементов, или длину вектора (`VLENGTH`).
`abstract long`	`reduceLanesToLong(VectorOperators.Associative op)`	Возвращает значение, полученное в результате накопления значений всех элементов этого вектора.
`abstract long`	`reduceLanesToLong(VectorOperators.Associative op, VectorMask<Byte> m)`	Возвращает значение, полученное в результате накопления значений выбранных элементов этого вектора, определяемых маской.
`abstract <F> Vector<F>`	`reinterpretShape(VectorSpecies<F> species, int part)`	Преобразует этот вектор в вектор заданного вида с типом элемента `F`, переинтерпретируя байты этого вектора без преобразования значений.
`abstract VectorShape`	`shape()`	Возвращает форму этого вектора.
`abstract VectorShuffle<Byte>`	`toShuffle()`	Преобразует этот вектор в перестановку, преобразуя значения элементов в `int` и рассматривая их как исходные индексы.

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

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

Модификатор и тип	Метод	Описание
`protected Object`	`clone()`	Создает и возвращает копию этого объекта.
`protected void`	`finalize()`	Устарело, будет удалено: этот элемент API подлежит удалению в будущей версии. Финализация устарела и подлежит удалению в одном из следующих выпусков.
`final Class<?>`	`getClass()`	Возвращает класс времени выполнения этого `Object`.
`final void`	`notify()`	Пробуждает один поток, ожидающий на мониторе этого объекта.
`final void`	`notifyAll()`	Пробуждает все потоки, ожидающие на мониторе этого объекта.
`final void`	`wait()`	Заставляет текущий поток ожидать пробуждения, обычно в результате уведомления или прерывания.
`final void`	`wait(long timeoutMillis)`	Заставляет текущий поток ожидать пробуждения, обычно в результате уведомления или прерывания, либо истечения определенного промежутка реального времени.
`final void`	`wait(long timeoutMillis, int nanos)`	Заставляет текущий поток ожидать пробуждения, обычно в результате уведомления или прерывания, либо истечения определенного промежутка реального времени.

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

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)

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

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

broadcast

public abstract ByteVector broadcast(byte e)

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

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

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

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

Параметры:

e — значение для распространения

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

e — значение для распространения

Возвращает:

вектор, в котором все элементы установлены в примитивное значение 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 — значение для распространения

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

e — значение для распространения

Возвращает:

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

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

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

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Unary op)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

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

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 результирующего вектора помещается значение элемента по умолчанию.

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

Параметры:: 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 — если для какой-либо полосы N вектора выполняется условие offset+N < 0 или offset+N >= a.length

intoBooleanArray

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

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

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

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

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

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

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]].

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

Параметры:

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]].

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

Параметры:

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 результата.

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

В результате сочетания сохранения формы и изменения размера элементов входной и выходной наборы типов могут иметь разное количество элементов, что приводит к расширению или сжатию и требует выбора или вставки. В концептуальном смысле входные данные преобразуются поэлементно в логический результат, содержащий все преобразованные элементы, что приводит к логическому коэффициенту расширения ML = |FTYPE|/|ETYPE|. Затем результат копируется на выход, который может точно соответствовать результату (без остатка), быть меньше него (требуется выбор) или больше него (требуется вставка).

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

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

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

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

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

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

Сохранение формы может требовать выбора или вставки

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

Для управления деталями этих расширений и сжатий параметр part выбирает часть результата при расширении или задаёт место вставки результатов сжатия в выходной вектор. Для преобразований с сохранением формы (MP=1) возможны следующие случаи:

Поэлементный оператор преобразования без изменения размера (|ETYPE|=|FTYPE|): входные данные, логический результат и выходные данные имеют одинаковое количество элементов и размер в битах (ML=MP=1). Логический результат точно соответствует выходным данным, поэтому всегда выполняется part=0.
Все преобразованные элементы возвращаются в одном выходном векторе, без неиспользуемых элементов.
Поэлементный расширяющий оператор преобразования (|ETYPE|<|FTYPE|): логическое расширение ML=|FTYPE|/|ETYPE|>1 означает, что логический результат в MS=ML раз больше выходных данных.
Число part в диапазоне [0..MS-1] выбирает один из MS различных блоков по VLENGTH/MS элементов логического результата, начиная с начального элемента part*VLENGTH/MS. Выбранный блок копируется в выходные данные и точно заполняет их. Остальная часть логического результата отбрасывается.

Группа таких выходных векторов с MS непересекающимися выбранными частями логических результатов может (вручную) представлять полный логический результат преобразования.
Поэлементный сжимающий оператор преобразования (|ETYPE|>|FTYPE|): логическое сжатие ML=|FTYPE|/|ETYPE|<1 означает, что выходные данные в MO=1/ML раз больше логического результата.
Число part в диапазоне [-(MO-1)..0] вставляет все VLENGTH элементов логического результата в выходные данные, начиная с начального элемента -part*VLENGTH. Всего имеется VLENGTH*MO выходных элементов; элементы, не содержащие преобразованных входных значений, заполняются нулями.

Группу таких выходных векторов, в которых части логического результата направлены в MO непересекающихся блока, можно (вручную) собрать с помощью оператора побитового исключающего ИЛИ или (для чисел с плавающей запятой) оператора FIRST_NONZERO.

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

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

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(). В противном случае это операция с изменением формы, которая может иметь особые затраты на реализацию.

В результате сочетания изменения формы и размера элементов входная и выходная спецификации могут иметь разное количество элементов, что приводит к расширению или сжатию и требует выбора или вставки. В концептуальном смысле входные данные преобразуются поэлементно в логический результат, содержащий все преобразованные элементы, что приводит к логическому коэффициенту расширения ML = |FTYPE|/|ETYPE|. Затем результат копируется на выход, который может точно соответствовать результату (без остатка), быть меньше него (требуется выбор) или больше него (требуется вставка).

Точное соответствие (без изменения размера): расширение или сжатие физической формы соответствует расширению или сжатию элементов (MP=ML). Должно выполняться part=0.
Логический результат в MS>1 раз больше выходной формы (выбор): число part в диапазоне [0..MS-1] определяет, какая из MS различных частей логического результата будет выбрана для выходных данных. Остальная часть логического результата отбрасывается.
Выходная форма в MO>1 раз больше логического результата (вставка): число part в диапазоне [-(MO-1)..0] определяет, в какое из MO различных положений выходных данных будет вставлен логический результат. Остальная часть выходных данных дополняется нулевыми битами.

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

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) { // MS=MO=1 => in-place
    assert part == 0; //else AIOOBE
    physical = logical;
} else if (domlen > ranlen) { // MS>1 => selection
    int MS = domlen / ranlen;
    assert 0 <= part && part < MS; //else AIOOBE
    int origin = part * ranlen;
    physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
} else { // (domlen < ranlen) // MO>1 => insertion, padding
    int MO = ranlen / domlen;
    assert 0 >= part && part > -MO; //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.