Класс ByteVector

java.lang.Object

jdk.incubator.vector.Vector<Byte>

jdk.incubator.vector.ByteVector

public abstract class ByteVector extends Vector<Byte>

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

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

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

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

Modifier and Type	Method	Description
`final ByteVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final ByteVector`	`add(byte e)`	Добавляет этот вектор к широковещательной передаче входного скаляра.
`final ByteVector`	`add(byte e, VectorMask<Byte> m)`	Добавляет этот вектор к широковещательной передаче входного скаляра, выбирая элементы регистров, управляемые маской.
`final ByteVector`	`add(Vector<Byte> v)`	Добавляет этот вектор ко второму входному вектору.
`final ByteVector`	`add(Vector<Byte> v, VectorMask<Byte> m)`	Добавляет этот вектор ко второму входному вектору, выбирая регистры под управлением маски.
`abstract ByteVector`	`addIndex(int scale)`	Добавляет регистры этого вектора к соответствующим номерам регистров, масштабированным заданной константой.
`final ByteVector`	`and(byte e)`	Вычисляет побитовое логическое И (`&`) этого вектора и скаляра.
`final ByteVector`	`and(Vector<Byte> v)`	Вычисляет побитовое логическое И (`&`) этого вектора и второго входного вектора.
`final ByteVector`	`bitwiseBlend(byte bits, byte mask)`	Смешивает биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(byte bits, Vector<Byte> mask)`	Смешивает биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, byte mask)`	Смешивает биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)`	Смешивает биты двух векторов под управлением третьего, который предоставляет биты маски.
`final ByteVector`	`blend(byte e, VectorMask<Byte> m)`	Заменяет выбранные регистры этого вектора значением скаляра под управлением маски.
`final ByteVector`	`blend(long e, VectorMask<Byte> m)`	Заменяет выбранные регистры этого вектора значением скаляра под управлением маски.
`abstract ByteVector`	`blend(Vector<Byte> v, VectorMask<Byte> m)`	Заменяет выбранные регистры этого вектора соответствующими регистрами из второго входного вектора под управлением маски.
`abstract ByteVector`	`broadcast(byte e)`	Возвращает вектор того же типа, что и этот, где все элементы регистров установлены в примитивное значение `e`.
`abstract ByteVector`	`broadcast(long e)`	Возвращает вектор того же типа, что и этот, где все элементы регистров установлены в примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, byte e)`	Возвращает вектор заданного типа, где все элементы регистров установлены в примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, long e)`	Возвращает вектор заданного типа, где все элементы регистров установлены в примитивное значение `e`.
`final <F> Vector<F>`	`castShape(VectorSpecies<F> toSpecies, int part)`	Удобный метод для преобразования вектора из одного типа регистров в другой, переформировывая при необходимости, когда размеры регистров изменяются.
`final <F> Vector<F>`	`check(Class<F> elementType)`	Проверяет, что этот вектор имеет заданный тип элемента, и возвращает этот вектор без изменений.
`final <F> Vector<F>`	`check(VectorSpecies<F> species)`	Проверяет, что этот вектор имеет заданный тип, и возвращает этот вектор без изменений.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения, в регистрах, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения, в регистрах, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, Vector<Byte> v)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`abstract ByteVector`	`compress(VectorMask<Byte> m)`	Сжимает элементы регистров этого вектора, выбирая регистры под управлением определенной маски.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Byte,F> conv, int part)`	Преобразует этот вектор в вектор той же формы и нового типа элемента, преобразуя значения регистров из текущего `ETYPE` в новый тип регистров (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Byte,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного типа, формы и типа элемента, преобразуя значения регистров из текущего `ETYPE` в новый тип регистров (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`final ByteVector`	`div(byte e)`	Делит этот вектор на широковещательную передачу входного скаляра.
`final ByteVector`	`div(byte e, VectorMask<Byte> m)`	Делит этот вектор на широковещательную передачу входного скаляра, выбирая элементы регистров, управляемые маской.
`final ByteVector`	`div(Vector<Byte> v)`	Делит этот вектор на второй входной вектор.
`final ByteVector`	`div(Vector<Byte> v, VectorMask<Byte> m)`	Делит этот вектор на второй входной вектор под управлением маски.
`final VectorMask<Byte>`	`eq(byte e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Byte>`	`eq(Vector<Byte> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`abstract ByteVector`	`expand(VectorMask<Byte> m)`	Расширяет элементы регистров этого вектора под управлением определенной маски.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset)`	Загружает вектор из массива типа `byte[]`, начиная с смещения.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, состоящий из элементов из массива типа `byte[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Собрать новый вектор, состоящий из элементов из массива типа `byte[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static ByteVector`	`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)`	Загружает вектор из массива типа `byte[]`, начиная со смещения, и используя маску.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset)`	Загружает вектор из массива типа `boolean[]`, начиная со смещения.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, состоящий из элементов из массива типа `boolean[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Собрать новый вектор, состоящий из элементов из массива типа `boolean[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static ByteVector`	`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)`	Загружает вектор из массива типа `boolean[]`, начиная со смещения, и используя маску.
`static ByteVector`	`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная со смещения в сегмент памяти.
`static ByteVector`	`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)`	Загружает вектор из сегмента памяти, начиная со смещения в сегмент памяти, и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает код хэширования для вектора.

`final void`	`intoArray(byte[] a, int offset)`	Сохраняет этот вектор в массив типа `byte[]`, начиная со смещения.
`final void`	`intoArray(byte[] a, int offset, int[] indexMap, int mapOffset)`	Разбрасывает этот вектор в массив типа `byte[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Разбрасывает этот вектор в массив типа `byte[]` под управлением маски и с использованием индексов, полученных путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(byte[] a, int offset, VectorMask<Byte> m)`	Сохраняет этот вектор в массив типа `byte[]`, начиная со смещения и используя маску.
`final void`	`intoBooleanArray(boolean[] a, int offset)`	Сохраняет этот вектор в массив типа `boolean[]`, начиная со смещения.
`final void`	`intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset)`	Разбрасывает этот вектор в массив типа `boolean[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoBooleanArray(boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`	Разбрасывает этот вектор в массив типа `boolean[]` под управлением маски и с использованием индексов, полученных путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoBooleanArray(boolean[] a, int offset, VectorMask<Byte> m)`	Сохраняет этот вектор в массив типа `boolean[]`, начиная со смещения и используя маску.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная со смещения, с использованием явного порядка байтов.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)`	Сохраняет этот вектор в сегмент памяти, начиная со смещения, с использованием явного порядка байтов и маски.
`abstract byte`	`lane(int i)`	Получает элемент дорожки по индексу дорожки `i`
`final ByteVector`	`lanewise(VectorOperators.Binary op, byte e)`	Объединяет значения дорожек этого вектора со значением скаляра с широковещательной трансляцией.
`final ByteVector`	`lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)`	Объединяет значения дорожек этого вектора со значением скаляра с широковещательной трансляцией, с выбором элементов дорожек, управляемых маской.
`final ByteVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения дорожек этого вектора со значением скаляра с широковещательной трансляцией.
`final ByteVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)`	Объединяет соответствующие значения дорожек этого вектора со значениями второго входного вектора, с выбором элементов дорожек, управляемых маской.
`abstract ByteVector`	`lanewise(VectorOperators.Binary op, Vector<Byte> v)`	Объединяет соответствующие значения дорожек этого вектора со значениями второго входного вектора.
`abstract ByteVector`	`lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)`	Объединяет соответствующие значения дорожек этого вектора со значениями второго входного вектора, с выбором элементов дорожек, управляемых маской.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, byte e2)`	Объединяет значения дорожек этого вектора со значениями двух скаляров с широковещательной трансляцией.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)`	Объединяет значения дорожек этого вектора со значениями двух скаляров с широковещательной трансляцией, с выбором элементов дорожек, управляемых маской.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)`	Объединяет значения дорожек этого вектора со значениями другого вектора и скаляра с широковещательной трансляцией.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)`	Объединяет значения дорожек этого вектора со значениями другого вектора и скаляра с широковещательной трансляцией, с выбором элементов дорожек, управляемых маской.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)`	Объединяет значения дорожек этого вектора со значениями другого вектора и скаляра с широковещательной трансляцией.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)`	Объединяет значения дорожек этого вектора со значениями другого вектора и скаляра с широковещательной трансляцией, с выбором элементов дорожек, управляемых маской.
`abstract ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов.
`abstract ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов, с выбором элементов дорожек, управляемых маской.
`abstract ByteVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операции над значениями дорожек этого вектора.
`abstract ByteVector`	`lanewise(VectorOperators.Unary op, VectorMask<Byte> m)`	Осуществляет операции над значениями дорожек этого вектора, с выбором элементов дорожек, управляемых маской.
`final VectorMask<Byte>`	`lt(Vector<Byte> v)`	Проверяет, меньше ли этот вектор, чем входной скаляр.
`final VectorMask<Byte>`	`maskAll(boolean bit)`	Проверяет, меньше ли этот вектор, чем другой входной вектор.
`final VectorMask<Byte>`	`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)`	Вычисляет битовую логическую дизъюнкцию (`\|`) этого вектора и скаляра.
`final ByteVector`	`rearrange(VectorShuffle<Byte> shuffle)`	Вычисляет битовую логическую дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определенного перемешивания.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)`	Переупорядочивает элементы дорожек двух векторов, выбирая дорожки под управлением определенного перемешивания, используя как нормальные, так и исключительные индексы в перемешивании для управления данными.
`abstract ByteVector`	`reduceLanes(VectorOperators.Associative op)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определенного перемешивания и маски.
`abstract byte`	`reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)`	Возвращает значение, накопленное со всех дорожек этого вектора.
`abstract byte`	`reinterpretAsBytes()`	Возвращает значение, накопленное с выбранных дорожек этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsDoubles()`	Представляет этот вектор как вектор той же формы и содержимого, но типа дорожек `byte`, где байты извлекаются из дорожек в соответствии с порядком little-endian.
`DoubleVector`	`double`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа дорожек `double`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.

END_OF_DOCUMENT_MARKER

`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> v1, Vector<Byte> v2)`	Используя значения, хранящиеся в каналах этого вектора, собирает значения, хранящиеся во втором векторе `v1` и третьем векторе `v2`.
`abstract ByteVector`	`selectFrom(Vector<Byte> s, VectorMask<Byte> m)`	Используя значения индексов, хранящиеся в каналах этого вектора, собирает значения во втором векторе под управлением маски.
`abstract ByteVector`	`slice(int origin)`	Вырезает сегмент смежных каналов, начиная с заданного канала `origin` в текущем векторе.
`abstract ByteVector`	`slice(int origin, Vector<Byte> v1)`	Вырезает сегмент смежных каналов, начиная с заданного канала `origin` в текущем векторе и продолжая (при необходимости) в непосредственно следующий вектор.
`final ByteVector`	`slice(int origin, Vector<Byte> w, VectorMask<Byte> m)`	Вырезает сегмент смежных каналов под управлением маски, начиная с заданного канала `origin` в текущем векторе и продолжая (при необходимости) в непосредственно следующий вектор.
`final VectorSpecies<Byte>`	`species()`	Возвращает вид текущего вектора.
`final ByteVector`	`sub(byte e)`	Вычитает входной скаляр из этого вектора.
`final ByteVector`	`sub(byte e, VectorMask<Byte> m)`	Вычитает входной скаляр из этого вектора под управлением маски.
`final ByteVector`	`sub(Vector<Byte> v)`	Вычитает второй входной вектор из этого вектора.
`final ByteVector`	`sub(Vector<Byte> v, VectorMask<Byte> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Byte>`	`test(VectorOperators.Test op)`	Проверяет каналы этого вектора в соответствии с заданной операцией.
`abstract VectorMask<Byte>`	`test(VectorOperators.Test op, VectorMask<Byte> m)`	Проверяет выбранные каналы этого вектора в соответствии с заданной операцией.
`final byte[]`	`toArray()`	Возвращает массив типа `byte[]`, содержащий все значения каналов.
`final double[]`	`toDoubleArray()`	Возвращает массив `double[]`, содержащий все значения каналов, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив `int[]`, содержащий все значения каналов, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает массив `long[]`, содержащий все значения каналов, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора в формате `"[0,1,2...]"`, отображая значения каналов этого вектора в порядке каналов.
`abstract ByteVector`	`unslice(int origin)`	Инвертирует slice(), вставляя текущий вектор как срез в «фоновый» вход с нулевыми значениями каналов.
`abstract ByteVector`	`unslice(int origin, Vector<Byte> w, int part)`	Инвертирует slice(), вставляя текущий вектор как срез в другой «фоновый» входной вектор, который рассматривается как один из входов для гипотетической последующей операции `slice()`.
`abstract ByteVector`	`unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)`	Инвертирует slice(), вставляя (под управлением маски) текущий вектор как срез в другой «фоновый» входной вектор, который рассматривается как один из входов для гипотетической последующей операции `slice()`.
`final Vector<?>`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом канала, являющимся типом с плавающей точкой.
`final ByteVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом канала, не являющимся типом с плавающей точкой.
`abstract ByteVector`	`withLane(int i, byte e)`	Заменяет элемент канала этого вектора в канале с индексом `i` значением `e`.
`static ByteVector`	`zero(VectorSpecies<Byte> species)`	Возвращает вектор заданного вида, где все элементы каналов установлены в ноль — значение по умолчанию для примитивного типа.

Методы, объявленные в классе 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

Species representing ByteVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Byte> SPECIES_128

Species representing ByteVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Byte> SPECIES_256

Species representing ByteVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Byte> SPECIES_512

Species representing ByteVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Byte> SPECIES_MAX

Species representing ByteVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Byte> SPECIES_PREFERRED

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

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

zero

public static ByteVector zero(VectorSpecies<Byte> species)

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

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

broadcast

public abstract ByteVector broadcast(byte e)

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

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

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

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

Параметры:

e - значение для широковещательной рассылки

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

species - species нужного вектора

e - значение для широковещательной рассылки

Возвращает:

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

См. также:

broadcast

public abstract ByteVector broadcast(long e)

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

Значение long e должно точно представляться ETYPE species этого вектора, так что 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)

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

Параметры:

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

Объединяет значения элементов этого вектора со значением вещаемого скаляра. Это бинарная операция по элементам, которая применяет выбранную операцию к каждому элементу. Результат будет равен этому выражению: this.lanewise(op, this.broadcast(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 - маска, управляющая выбором канала

Возвращает:

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

См. также:

div

public final ByteVector div(Vector<Byte> v)

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

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

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

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

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

Если существует делитель на ноль,


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

div

public final ByteVector div(byte e)

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

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

Если существует делитель на ноль,


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

div

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

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

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

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

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

Если существует делитель на ноль,


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

Если существует делитель на ноль,


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

min

public final ByteVector min(Vector<Byte> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final ByteVector min(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final ByteVector max(Vector<Byte> v)

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

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

Указано:

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

Параметры:

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

Возвращает:

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

См. также:

max

public final ByteVector max(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final ByteVector and(Vector<Byte> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final ByteVector and(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final ByteVector or(Vector<Byte> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final ByteVector or(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final ByteVector neg()

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

Указано:

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

Возвращает:

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

См. также:

abs

public final ByteVector abs()

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

Указано:

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

Возвращает:

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

См. также:

не

public final ByteVector not()

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

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

Возвращает:

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

См. также:

равно

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

равно

public final VectorMask<Byte> eq(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

меньше

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

меньше

public final VectorMask<Byte> lt(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

тест

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

тест

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

сравнение

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

сравнение

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

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

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

Параметры:

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

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

Возвращает:

См. также:

сравнение

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 вычисляет значение масштабированного индекса addIndex и добавляет его к значению, уже находящемуся в элементе 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 - маска, управляющая выбором элемента в результирующий вектор

Возвращает:

См. также:

END_OF_DOCUMENT_MARKER

slice

public abstract ByteVector slice(int origin)

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


 (origin,

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

Параметры:

origin - первая входная полоса для переноса в срез

Возвращает:

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

См. также:

unslice

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

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

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

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

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

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

Параметры:

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

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

part - номер части результата (либо ноль, либо один)

Возвращает:

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

См. также:

unslice

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

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

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

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

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

Параметры:

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

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

part - номер части результата (либо ноль, либо один)

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

Возвращает:

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

См. также:

unslice

public abstract ByteVector unslice(int origin)

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


 (origin,

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract ByteVector rearrange(VectorShuffle<Byte> shuffle)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

END_OF_DOCUMENT_MARKER

Переупорядочить

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

selectFrom

public abstract ByteVector selectFrom(Vector<Byte> v)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

selectFrom

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

Используя значения, хранящиеся в проходах этого вектора, собирает значения, хранящиеся во втором векторе v1 и третьем векторе v2. Таким образом, второй и третий векторы служат таблицей, элементы которой выбираются по индексам в этом векторе. Это операция между проходами, которая переупорядочивает элементы проходов аргументных векторов под управлением этого вектора. Для каждого прохода N этого вектора и для каждого значения прохода I=wrapIndex(this.lane(N) в этом векторе, выходной проход N получает значение из второго вектора на проходе I, если I < VLENGTH. В противном случае, выходной проход N получает значение из третьего вектора на проходе I - VLENGTH. Здесь VLENGTH является результатом this.length(), а для целочисленных значений wrapIndex вычисляет результат Math.floorMod(E, 2 * VLENGTH), где E — индекс для оборачивания. Если VLENGTH является степенью двойки, то результат также равен E & (2 * VLENGTH - 1). Для чисел с плавающей точкой wrapIndex вычисляет Math.floorMod(convert(E), 2 * VLENGTH), где convert преобразует число с плавающей точкой в целочисленное значение с тем же количеством битов представления — как при преобразовании значения double в long ((long)doubleVal) или значения float в int ((int)floatVal). Таким образом, результат содержит только значения, хранящиеся в аргументных векторах v1 и v2, но представленные в порядке, зависящем от значений индексов в this. Результат для целочисленных значений такой же, как выражение

v1.rearrange(
this.lanewise(VectorOperators.AND, 2 * VLENGTH - 1).toShuffle(),
v2)

, когда VLENGTH является степенью двойки. Векторно-последовательная AND операция даёт вектор, элементы которого находятся в диапазоне [0, 2 * VLENGTH - 1]). Преобразование перестановки приводит к частично обернутой перестановке, индексы которой находятся в диапазоне [-VLENGTH, VLENGTH - 1]), где исключительные индексы используются для выбора элементов в третьем векторе.

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

См. также:

lane

public abstract byte lane(int i)

Получает элемент элемента с индексом i

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

withLane

public abstract ByteVector withLane(int i, byte e)

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

Parameters:: i - индекс канала элемента канала, который нужно заменить; e - значение, которое нужно поместить
Returns:: результат замены элемента канала этого вектора в индексе канала i значением e.
Throws:: IllegalArgumentException - если индекс находится вне диапазона (< 0 || >= length())

toArray

public final byte[] toArray()

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

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


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

Specified by:

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

Returns:

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

See Also:

toIntArray

public final int[] toIntArray()

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


 float

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

toLongArray

public final long[] toLongArray()

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


 float

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

Specified by:

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

Implementation Note:

Returns:

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

See Also:

toDoubleArray

public final double[] toDoubleArray()

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

fromArray

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

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

Parameters:: species — вид желаемого вектора; a — массив; offset — смещение в массиве
Returns:: вектор, загруженный из массива
Throws:: 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.

Parameters:: species — вид желаемого вектора; a — массив; offset — смещение в массиве; m — маска, управляющая выбором канала
Returns:: вектор, загруженный из массива
Throws:: 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]].

Parameters:

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

a — массив

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

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

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

Returns:

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

Throws:

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

See Also:

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

Parameters:

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

a - массив

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

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

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

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

Returns:

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

Throws:

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

See Also:

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.

Parameters:: species - вид желаемого вектора; a - массив; offset - смещение в массиве
Returns:: вектор, загруженный из массива
Throws:: 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.

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

fromBooleanArray

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

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

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

Parameters:

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

a - массив

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

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

Returns:

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

Throws:

See Also:

fromBooleanArray

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

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

See Also:

fromMemorySegment

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

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

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


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

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

fromMemorySegment

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

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

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


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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Параметры:

a - массив

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

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

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

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

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

См. также:

intoArray

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

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

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

Параметры:

a - массив

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

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

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

m - маска

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

См. также:

intoBooleanArray

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

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

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

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

intoBooleanArray

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

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

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

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

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

intoBooleanArray

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

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

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

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

Parameters:

a - массив

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

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

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

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, 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(MemorySegment ms, long offset, ByteOrder bo)

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

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

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


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

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

intoMemorySegment

public final void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)

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

Следующий псевдокод иллюстрирует поведение, где JAVA_E — расположение типа примитивного элемента, ETYPE — тип примитивного элемента, и EVector — тип примитивного вектора для этого вектора:


 ETYPE[] a = this.toArray();
 var slice = ms.asSlice(offset)
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         slice.setAtIndex(ValueLayout.JAVA_E.withBitAlignment(8), n);
     }
 }

Specified by:: intoMemorySegment in class 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:

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:: вектор ShortVector с той же формой и информационным содержимым

reinterpretAsInts

public IntVector reinterpretAsInts()

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

Specified by:: reinterpretAsInts in class Vector<E>
Returns:: вектор IntVector с той же формой и информационным содержимым

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

Specified by:: reinterpretAsLongs in class Vector<E>
Returns:: вектор LongVector с той же формой и информационным содержимым

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

Specified by:: reinterpretAsFloats in class Vector<E>
Returns:: вектор FloatVector с той же формой и информационным содержимым

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

Specified by:: reinterpretAsDoubles in class Vector<E>
Returns:: вектор 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 выходных элементов, а те, которые не содержат преобразованные входные значения, заполняются нулями.
Группа таких выходных векторов с логическими частями результата, направленными в отдельные блоки, может быть собрана с помощью оператора побитового или (bitwise or) или (для чисел с плавающей точкой) оператора 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>

Type Parameters:

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

Parameters:

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

part - номер части результата или ноль, если не расширяется и не сокращается

Returns:

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

See Also:

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 параметр выбирает частичные результаты из расширенного логического результата или направляет результаты сокращенного логического результата в физический выходной вектор требуемого выходного вида.

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


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

Указано:

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

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

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

Параметры:

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

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

part - номер части результата или ноль, если не происходит ни расширения, ни сокращения

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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