Класс ByteVector

java.lang.Object

jdk.incubator.vector.Vector<Byte>

jdk.incubator.vector.ByteVector

public abstract class ByteVector extends Vector<Byte>

ByteVector опирается на предварительные возможности платформы Java:

ByteVector относится к одному или нескольким предварительным API: MemorySegment.

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

Предварительные возможности могут быть удалены в будущей версии или переведены в постоянные возможности платформы Java.

Специализированный 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^PREVIEW ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти.

`static ByteVector`	`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment^PREVIEW 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^PREVIEW ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти^ПРЕВЬЮ, начиная со смещения, с использованием явного порядка байтов.
`final void`	`intoMemorySegment(MemorySegment^PREVIEW 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> m)`	Переупорядочивает элементы каналов этого вектора, выбирая каналы под управлением определённого перемещения.
`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`, где байты извлекаются из каналов в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но с типом канала `double`, где каналы собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но с типом канала `float`, где каналы собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но с типом канала `int`, где каналы собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но с типом канала `long`, где каналы собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но с типом канала `short`, где каналы собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract ByteVector`	`selectFrom(Vector<Byte> v)`	Используя значения индексов, хранящиеся в каналах этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`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)`	Возвращает вектор заданного вида, где все элементы канала установлены в ноль — значение по умолчанию для примитивного типа.

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Byte> SPECIES_64

Тип, представляющий ByteVector с VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Byte> SPECIES_128

Тип, представляющий ByteVector с VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Byte> SPECIES_256

Тип, представляющий ByteVector с VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Byte> SPECIES_512

Тип, представляющий ByteVector с VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Byte> SPECIES_MAX

Тип, представляющий ByteVector с VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Byte> SPECIES_PREFERRED

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

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

zero

public static ByteVector zero(VectorSpecies<Byte> species)

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

Параметры:: 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)

Возвращает вектор того же типа, что и этот, где все элементы канала установлены в значение e. Значение EVector должно быть точно представимо разрядностью 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).

Parameters:

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

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

Returns:

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

See Also:

sub

public final ByteVector sub(Vector<Byte> v)

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

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

Specified by:

sub in class Vector<Byte>

Parameters:

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

Returns:

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

See Also:

sub

public final ByteVector sub(byte e)

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

Parameters:

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

Returns:

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

See Also:

sub

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

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

Specified by:

sub in class Vector<Byte>

Parameters:

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

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

Returns:

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

See Also:

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final ByteVector mul(Vector<Byte> v)

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

Specified by:

mul in class Vector<Byte>

Parameters:

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

Returns:

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

See Also:

mul

public final ByteVector mul(byte e)

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

Parameters:

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

Returns:

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

See Also:

mul

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

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

Specified by:

mul in class Vector<Byte>

Parameters:

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

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

Returns:

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

See Also:

умножение

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

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

Параметры:

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

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

Возвращает:

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

См. также:

деление

public final ByteVector div(Vector<Byte> v)

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

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

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

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

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

Если есть делитель ноль,


 ArithmeticException

будет выброшено.

Параметры:

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

Возвращает:

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

См. также:

деление

public final ByteVector div(byte e)

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

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

Если есть делитель ноль,


 ArithmeticException

будет выброшено.

Параметры:

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

Возвращает:

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

См. также:

деление

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

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

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

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

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

Если есть делитель ноль,


 ArithmeticException

будет выброшено.

Параметры:

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

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

Возвращает:

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

См. также:

деление

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

max

public final ByteVector max(byte e)

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

Parameters:

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

Returns:

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

See Also:

and

public final ByteVector and(Vector<Byte> v)

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

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

Parameters:

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

Returns:

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

See Also:

and

public final ByteVector and(byte e)

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

Parameters:

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

Returns:

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

See Also:

or

public final ByteVector or(Vector<Byte> v)

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

Parameters:

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

Returns:

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

See Also:

or

public final ByteVector or(byte e)

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

Parameters:

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

Returns:

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

See Also:

neg

public final ByteVector neg()

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

Specified by:

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

Returns:

изменение знака этого вектора

See Also:

abs

public final ByteVector abs()

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

Specified by:

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

Returns:

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

See Also:

not

public final ByteVector not()

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

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

Возвращает:

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

См. также:

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


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

и добавляет его к значению, уже находящемуся в канале 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> m)

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

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

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

Параметры:

m - переупорядочение, управляющее выбором индекса прохода

Возвращает:

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

См. также:

rearrange

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

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

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


 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);

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

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

Параметры:

s - переупорядочение, управляющее выбором индекса прохода

m - маска, управляющая применением переупорядочения

Возвращает:

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

См. также:

Перестановка

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 - второй входной вектор

Возвращает:

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

См. также:

сжать

public abstract ByteVector compress(VectorMask<Byte> m)

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

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

расширить

public abstract ByteVector expand(VectorMask<Byte> m)

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

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

выбиратьИз

public abstract ByteVector selectFrom(Vector<Byte> v)

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

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

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

Параметры:

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

Возвращает:

переупорядочение элементов проходов v

См. также:

выбиратьИз

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

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

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

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

Параметры:

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

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

Возвращает:

переупорядочение элементов проходов v

См. также:

побитовоеСлияние

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

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

Параметры:

bits - входные биты для слияния в текущий вектор

mask - побитовая маска для включения слияния входных битов

Возвращает:

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

См. также:

побитовоеСлияние

public final ByteVector bitwiseBlend(byte bits, byte mask)

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

Параметры:

bits - входные биты для слияния в текущий вектор

mask - побитовая маска для включения слияния входных битов

Возвращает:

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

См. также:

побитовоеСлияние

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

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

Параметры:

bits - входные биты для слияния в текущий вектор

mask - побитовая маска для включения слияния входных битов

Возвращает:

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

См. также:

Побитовое смешение

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 - если этот вектор не поддерживает запрошенную операцию

См. также:

запись

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 элементов во втором массиве ints, начиная с заданного mapOffset.

Для каждого канала вектора, где N — индекс канала вектора, канал загружается из выражения (byte) (a[f(N)] ? 1 : 0), где 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 в векторе

См. также:

fromBooleanArray

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

Считывает новый вектор, составленный из элементов массива типа boolean[], под управлением маски, и используя индексы, полученные путем добавления фиксированного offset к ряду вторичных смещений из карты индексов. Карта индексов — это непрерывная последовательность VLENGTH элементов во втором массиве ints, начиная с заданного 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, MemorySegmentPREVIEW 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 в векторе; IllegalArgumentException — если сегмент памяти — сегмент кучи, который не поддерживается массивом byte[].; IllegalStateException — если сессия сегмента памяти не активна или если доступ осуществляется из потока, отличного от потока, владеющего сессией.
С:: 19

fromMemorySegment

public static ByteVector fromMemorySegment(VectorSpecies<Byte> species, MemorySegmentPREVIEW 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 в векторе, где маска установлена; IllegalArgumentException — если сегмент памяти — сегмент кучи, который не поддерживается массивом byte[].; 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 элементов во втором массиве ints, начиная с заданного 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]].

Parameters:

a - массив

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

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

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

m - маска

Throws:

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

See Also:

intoBooleanArray

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

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

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

Parameters:: a - массив; offset - смещение в массиве
Throws:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любого элемента N вектора

intoBooleanArray

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

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

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

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

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

Parameters:: a - массив; offset - смещение в массиве; m - маска, управляющая выбором элемента
Throws:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любого элемента N вектора, где маска установлена

intoBooleanArray

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

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

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

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 — это значение байта.

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

intoMemorySegment

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

Сохраняет этот вектор в сегмент памяти^{ПРЕВЫДЕЛЕНИЕ}, начиная со смещения, используя явную кодировку байтов.

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

Этот метод работает так, как будто он вызывает intoMemorySegment()^{ПРЕВЫДЕЛЕНИЕ} следующим образом:


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

Specified by:: intoMemorySegment в классе Vector<Byte>
Parameters:: ms - сегмент памяти; offset - смещение в сегменте памяти; bo - предполагаемый порядок байтов
Since:: 19

intoMemorySegment

public final void intoMemorySegment(MemorySegmentPREVIEW 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);
     }
 }

Specified by:: intoMemorySegment в классе Vector<Byte>
Parameters:: ms - сегмент памяти; offset - смещение в сегменте памяти; bo - предполагаемый порядок байтов; m - маска, управляющая выбором элемента
Since:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

reinterpretAsBytes in class Vector<Byte>

Returns:

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

See Also:

viewAsIntegralLanes

public final ByteVector viewAsIntegralLanes()

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

Specified by:

viewAsIntegralLanes in class Vector<Byte>

Returns:

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

See Also:

viewAsFloatingLanes

public final Vector<?> viewAsFloatingLanes()

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

Specified by:

viewAsFloatingLanes in class Vector<Byte>

Implementation Note:

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

Returns:

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

See Also:

toString

public final String toString()

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

Specified by:: toString in class Vector<Byte>
Returns:: строка в форме "[0,1,2...]", отображающая значения дорожек этого вектора

equals

public final boolean equals(Object obj)

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

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

Specified by:

equals in class Vector<Byte>

Parameters:

obj - объект-ссылка для сравнения.

Returns:

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

See Also:

hashCode

public final int hashCode()

Возвращает значение хэш-кода для вектора, основанное на значениях дорожек и спецификации вектора.

Specified by:

hashCode in class Vector<Byte>

Returns:

значение хэш-кода для этого вектора

See Also:

species

public final VectorSpecies<Byte> species()

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

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

Specified by:: species in class Vector<E>
Returns:: вид этого вектора

check

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

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

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

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

Specified by:

check in class Vector<E>

Type Parameters:

F - упакованный тип элемента требуемой спецификации

Parameters:

species - требуемая спецификация

Returns:

тот же вектор

See Also:

check

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

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

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

Specified by:

check in class Vector<E>

Type Parameters:

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

Parameters:

elementType - требуемый тип дорожки

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Byte> maskAll(boolean bit)

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

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

Specified by:

maskAll in class Vector<E>

Parameters:

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

Returns:

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

See Also:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

Specified by:: reinterpretAsShorts in class Vector<E>
Returns:: a ShortVector с той же формой и информационным содержимым

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Specified by:

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

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

Specified by:

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

Type Parameters:

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

Parameters:

toSpecies - желаемый выходной вид

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

Returns:

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

See Also:

convertShape

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

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

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

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

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


 FTYPE scalar_conversion_op(ETYPE s);
 EVector a = ...;
 VectorSpecies<F> rsp = ...;
 int part = ...;
 VectorSpecies<E> dsp = a.species();
 int domlen = dsp.length();
 int ranlen = rsp.length();
 FTYPE[] logical = new FTYPE[domlen];
 for (int i = 0; i < domlen; i++) {
   logical[i] = scalar_conversion_op(a.lane(i));
 }
 FTYPE[] physical;
 if (domlen == ranlen) { // in-place
     assert part == 0; //else AIOOBE
     physical = logical;
 } else if (domlen > ranlen) { // expanding
     int M = domlen / ranlen;
     assert 0 <= part && part < M; //else AIOOBE
     int origin = part * ranlen;
     physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
 } else { // (domlen < ranlen) // contracting
     int M = ranlen / domlen;
     assert 0 >= part && part > -M; //else AIOOBE
     int origin = -part * domlen;
     System.arraycopy(logical, 0, physical, origin, domlen);
 }
 return FVector.fromArray(ran, physical, 0);

Specified by:

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

Type Parameters:

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

Parameters:

conv - желаемое скалярное преобразование для применения по длине

rsp - желаемый выходной вид

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

Returns:

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

See Also:

getPayload

protected final Object getPayload()

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