Класс ByteVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

jdk.internal.vm.vector.VectorSupport.Vector<E>

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.ByteVector

public abstract class ByteVector extends Vector<E>

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

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

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

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

Модификатор и тип	Метод	Описание
`final ByteVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final ByteVector`	`add(byte e)`	Добавляет этот вектор к трансляции входного скаляра.
`final ByteVector`	`add(byte e, VectorMask<Byte> m)`	Добавляет этот вектор к трансляции входного скаляра, выбирая элементы дорожки, управляемые маской.
`final ByteVector`	`add(Vector<Byte> v)`	Добавляет этот вектор ко второму входному вектору.
`final ByteVector`	`add(Vector<Byte> v, VectorMask<Byte> m)`	Добавляет этот вектор ко второму входному вектору, выбирая дорожки под управлением маски.
`abstract ByteVector`	`addIndex(int scale)`	Добавляет дорожки этого вектора к их соответствующим номерам дорожек, масштабированным заданной константой.
`final ByteVector`	`and(byte e)`	Вычисляет поразрядную логическую конъюнкцию (`&`) этого вектора и скаляра.
`final ByteVector`	`and(Vector<Byte> v)`	Вычисляет поразрядную логическую конъюнкцию (`&`) этого вектора и второго входного вектора.
`final ByteVector`	`bitwiseBlend(byte bits, byte mask)`	Комбинирует биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(byte bits, Vector<Byte> mask)`	Комбинирует биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, byte mask)`	Комбинирует биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final ByteVector`	`bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)`	Комбинирует биты двух векторов под управлением третьего, который предоставляет биты маски.
`final ByteVector`	`blend(byte e, VectorMask<Byte> m)`	Заменяет выбранные дорожки этого вектора значением скаляра под управлением маски.
`final ByteVector`	`blend(long e, VectorMask<Byte> m)`	Заменяет выбранные дорожки этого вектора значением скаляра под управлением маски.
`abstract ByteVector`	`blend(Vector<Byte> v, VectorMask<Byte> m)`	Заменяет выбранные дорожки этого вектора соответствующими дорожками из второго входного вектора под управлением маски.
`abstract ByteVector`	`broadcast(byte e)`	Возвращает вектор того же типа, что и этот, где все элементы дорожки установлены в примитивное значение `e`.
`abstract ByteVector`	`broadcast(long e)`	Возвращает вектор того же типа, что и этот, где все элементы дорожки установлены в примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, byte e)`	Возвращает вектор заданного типа, где все элементы дорожки установлены в примитивное значение `e`.
`static ByteVector`	`broadcast(VectorSpecies<Byte> species, long e)`	Возвращает вектор заданного типа, где все элементы дорожки установлены в примитивное значение `e`.
`final <F> Vector<F>`	`castShape(VectorSpecies<F> toSpecies, int part)`	Удобный метод для преобразования вектора из одного типа дорожки в другой, с переустановкой, если необходимо, при изменении размеров дорожки.
`final <F> Vector<F>`	`check(Class<F> elementType)`	Проверяет, что у этого вектора заданный тип элемента, и возвращает этот вектор без изменений.
`final <F> Vector<F>`	`check(VectorSpecies<F> species)`	Проверяет, что у этого вектора заданный вид, и возвращает этот вектор без изменений.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, byte e, VectorMask<Byte> m)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения на дорожках, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m)`	Тестирует этот вектор, сравнивая его с входным скаляром в соответствии с заданной операцией сравнения на дорожках, выбранных маской.
`abstract VectorMask<Byte>`	`compare(VectorOperators.Comparison op, Vector<Byte> v)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`final VectorMask<Byte>`	`compare(VectorOperators.Comparison op, Vector<Byte> v, 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)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`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`	`fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo)`	Загружает вектор из массива байтов, начиная со смещения.
`static ByteVector`	`fromByteArray(VectorSpecies<Byte> species, byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)`	Загружает вектор из массива байтов, начиная со смещения и используя маску.
`static ByteVector`	`fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo)`	Загружает вектор из байтового буфера, начиная со смещения в байтовом буфере.
`static ByteVector`	`fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)`	Загружает вектор из байтового буфера, начиная со смещения в байтовом буфере и используя маску.

`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`	`intoByteArray(byte[] a, int offset, ByteOrder bo)`	Хранит этот вектор в массиве байтов, начиная со смещения, используя явное указание порядка байтов.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Byte> m)`	Хранит этот вектор в массиве байтов, начиная со смещения, используя явное указание порядка байтов и маску.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)`	Хранит этот вектор в буфере байтов, начиная со смещения, используя явное указание порядка байтов.
`final void`	`intoByteBuffer(ByteBuffer bb, int 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)`	Объединяет соответствующие значения каналов этого вектора со значениями второго входного вектора.
`final 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)`	Объединяет соответствующие значения каналов этого вектора со значениями каналов второго и третьего входных векторов.
`final ByteVector`	`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)`	Объединяет соответствующие значения каналов этого вектора со значениями каналов второго и третьего входных векторов, с выбором элементов каналов, управляемых маской.
`abstract ByteVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операцию над значениями каналов этого вектора.
`final ByteVector`	`lanewise(VectorOperators.Unary op, VectorMask<Byte> m)`	Осуществляет операцию над значениями каналов этого вектора, с выбором элементов каналов, управляемых маской.
`final VectorMask<Byte>`	`lt(byte e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Byte>`	`lt(Vector<Byte> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Byte>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор, где каждый канал установлен или сброшен в соответствии с заданным одиночным булевым значением, которое транслируется на все каналы.
`final ByteVector`	`max(byte e)`	Вычисляет большее значение между этим вектором и транслированным входным скаляром.
`final ByteVector`	`max(Vector<Byte> v)`	Вычисляет большее значение между этим вектором и вторым входным вектором.
`final ByteVector`	`min(byte e)`	Вычисляет меньшее значение между этим вектором и транслированным входным скаляром.
`final ByteVector`	`min(Vector<Byte> v)`	Вычисляет меньшее значение между этим вектором и вторым входным вектором.
`final ByteVector`	`mul(byte e)`	Умножает этот вектор на транслированный входной скаляр.
`final ByteVector`	`mul(byte e, VectorMask<Byte> m)`	Умножает этот вектор на транслированный входной скаляр, выбирая элементы каналов, управляемые маской.
`final ByteVector`	`mul(Vector<Byte> v)`	Умножает этот вектор на второй входной вектор.
`final ByteVector`	`mul(Vector<Byte> v, VectorMask<Byte> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final ByteVector`	`neg()`	Изменяет знак этого вектора.
`final ByteVector`	`not()`	Вычисляет побитовое логическое отрицание (`~`) этого вектора.
`final ByteVector`	`or(byte e)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и скаляра.
`final ByteVector`	`or(Vector<Byte> v)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> m)`	Переупорядочивает элементы каналов этого вектора, выбирая каналы под управлением определённого сдвига.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`	Переупорядочивает элементы каналов двух векторов, выбирая каналы под управлением определённого сдвига, используя как обычные, так и исключительные индексы в сдвиге для управления данными.
`abstract ByteVector`	`rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)`	Переупорядочивает элементы каналов этого вектора, выбирая каналы под управлением определённого сдвига и маски.
`abstract byte`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное из всех каналов этого вектора.
`abstract byte`	`reduceLanes(VectorOperators.Associative op, VectorMask<Byte> m)`	Возвращает значение, накопленное из выбранных каналов этого вектора, контролируемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и содержимого, но с типом канала `byte`, где байты извлекаются из каналов в соответствии с порядком little-endian.

END_OF_DOCUMENT_MARKER

`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом значений в элементах `double`, где элементы собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом значений в элементах `float`, где элементы собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом значений в элементах `int`, где элементы собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом значений в элементах `long`, где элементы собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом значений в элементах `short`, где элементы собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract ByteVector`	`selectFrom(Vector<Byte> v)`	Используя значения индексов, хранящиеся в элементах этого вектора, собрать значения, хранящиеся во втором векторе `v`.
`abstract ByteVector`	`selectFrom(Vector<Byte> s, VectorMask<Byte> m)`	Используя значения индексов, хранящиеся в элементах этого вектора, собрать значения, хранящиеся во втором векторе, под управлением маски.
`abstract ByteVector`	`slice(int origin)`	Вырезает сегмент смежных элементов, начиная с заданного `origin` элемента в текущем векторе.
`abstract ByteVector`	`slice(int origin, Vector<Byte> v1)`	Вырезает сегмент смежных элементов, начиная с заданного `origin` элемента в текущем векторе и продолжая (при необходимости) в следующий вектор.
`final ByteVector`	`slice(int origin, Vector<Byte> w, VectorMask<Byte> m)`	Вырезает сегмент смежных элементов под управлением маски, начиная с заданного `origin` элемента в текущем векторе и продолжая (при необходимости) в следующий вектор.
`final VectorSpecies<Byte>`	`species()`	Возвращает вид этого вектора.
`final ByteVector`	`sub(byte e)`	Вычитает входной скаляр из этого вектора.
`final ByteVector`	`sub(byte e, VectorMask<Byte> m)`	Вычитает входной скаляр из этого вектора под управлением маски.
`final ByteVector`	`sub(Vector<Byte> v)`	Вычитает второй входной вектор из этого вектора.
`final ByteVector`	`sub(Vector<Byte> v, VectorMask<Byte> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Byte>`	`test(VectorOperators.Test op)`	Проверяет элементы этого вектора в соответствии с заданной операцией.
`final 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()`	Возвращает строковое представление этого вектора в форме `"[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, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle

Методы, объявленные в классе jdk.internal.vm.vector.VectorSupport.VectorPayload

getPayload

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

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

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

SPECIES_64

public static final VectorSpecies<Byte> SPECIES_64

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

SPECIES_128

public static final VectorSpecies<Byte> SPECIES_128

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

SPECIES_256

public static final VectorSpecies<Byte> SPECIES_256

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

SPECIES_512

public static final VectorSpecies<Byte> SPECIES_512

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

SPECIES_MAX

public static final VectorSpecies<Byte> SPECIES_MAX

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

SPECIES_PREFERRED

public static final VectorSpecies<Byte> SPECIES_PREFERRED

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

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

zero

public static ByteVector zero(VectorSpecies<Byte> species)

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

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

broadcast

public abstract ByteVector broadcast(byte e)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращает:

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

См. также:

broadcast

public abstract ByteVector broadcast(long e)

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

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public abstract ByteVector lanewise(VectorOperators.Unary op)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,byte)
lanewise(VectorOperators.Binary,byte,VectorMask)

lanewise

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,byte,VectorMask)

lanewise

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte,VectorMask)

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(VectorOperators.Binary,Vector,VectorMask)
lanewise(VectorOperators.Binary,byte)

lanewise

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)
lanewise(VectorOperators.Ternary,byte,byte)
lanewise(VectorOperators.Ternary,Vector,byte)
lanewise(VectorOperators.Ternary,byte,Vector)

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)
lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)

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(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,byte,byte,VectorMask)

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(VectorOperators.Ternary,Vector,Vector,VectorMask)
lanewise(VectorOperators.Ternary,byte,byte)

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(VectorOperators.Ternary,byte,byte)
lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)

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(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,byte,byte,VectorMask)
lanewise(VectorOperators.Ternary,Vector,byte)

lanewise

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

Параметры:

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

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

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

Возвращает:

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

Исключение:

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

См. также:

lanewise(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

Исключение:

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

См. также:

lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
lanewise(VectorOperators.Ternary,byte,Vector)

add

public final ByteVector add(Vector<Byte> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

add(byte)

add

public final ByteVector add(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

add(Vector)
broadcast(byte)
add(byte,VectorMask)
VectorOperators.ADD
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

add

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

add(byte,VectorMask)

add

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

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

Parameters:

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

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

Returns:

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

See Also:

add(Vector,VectorMask)
broadcast(byte)
add(byte)
VectorOperators.ADD
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

sub

public final ByteVector sub(Vector<Byte> v)

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

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

Specified by:

sub in class Vector<Byte>

Parameters:

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

Returns:

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

See Also:

sub(byte)

sub

public final ByteVector sub(byte e)

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

Parameters:

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

Returns:

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

See Also:

sub(Vector)
broadcast(byte)
sub(byte,VectorMask)
VectorOperators.SUB
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

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(byte,VectorMask)

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

sub(Vector,VectorMask)
broadcast(byte)
sub(byte)
VectorOperators.SUB
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

mul

public final ByteVector mul(Vector<Byte> v)

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

Specified by:

mul in class Vector<Byte>

Parameters:

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

Returns:

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

See Also:

mul(byte)

mul

public final ByteVector mul(byte e)

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

Parameters:

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

Returns:

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

See Also:

mul(Vector)
broadcast(byte)
mul(byte,VectorMask)
VectorOperators.MUL
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

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:

mul(byte,VectorMask)

mul

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul(Vector,VectorMask)
broadcast(byte)
mul(byte)
VectorOperators.MUL
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

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(Vector)
broadcast(byte)
div(byte,VectorMask)
VectorOperators.DIV
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

div

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

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

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

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

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

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


 ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div(byte,VectorMask)

div

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

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

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

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


 ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div(Vector,VectorMask)
broadcast(byte)
div(byte)
VectorOperators.DIV
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,byte)

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 - входной скаляр

Возвращает:

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

См. также:

min(Vector)
broadcast(byte)
VectorOperators.MIN
lanewise(VectorOperators.Binary,byte,VectorMask)

max

public final ByteVector max(Vector<Byte> v)

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

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

Specified by:

max in class Vector<Byte>

Parameters:

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

Returns:

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

See Also:

max

public final ByteVector max(byte e)

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

Parameters:

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

Returns:

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

See Also:

max(Vector)
broadcast(byte)
VectorOperators.MAX
lanewise(VectorOperators.Binary,byte,VectorMask)

and

public final ByteVector and(Vector<Byte> v)

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

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

Parameters:

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

Returns:

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

See Also:

and(byte)
or(Vector)
not()
VectorOperators.AND
lanewise(VectorOperators.Binary,Vector,VectorMask)

and

public final ByteVector and(byte e)

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

Parameters:

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

Returns:

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

See Also:

and(Vector)
VectorOperators.AND
lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final ByteVector or(Vector<Byte> v)

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

Parameters:

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

Returns:

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

See Also:

or(byte)
and(Vector)
not()
VectorOperators.OR
lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final ByteVector or(byte e)

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

Parameters:

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

Returns:

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

See Also:

or(Vector)
VectorOperators.OR
lanewise(VectorOperators.Binary,Vector,VectorMask)

neg

public final ByteVector neg()

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

Specified by:

neg in class Vector<Byte>

Returns:

отрицание этого вектора

See Also:

abs

public final ByteVector abs()

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

Specified by:

abs in class Vector<Byte>

Returns:

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

See Also:

not

public final ByteVector not()

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

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

Возвращает:

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

См. также:

and(Vector)
VectorOperators.NOT
lanewise(VectorOperators.Unary,VectorMask)

eq

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Byte> eq(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,byte)

lt

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Byte> lt(byte e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,byte)

test

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.test(VectorOperators.Test)

compare

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

Vector.compare(VectorOperators.Comparison, Vector)

compare

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

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

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

Параметры:

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

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

Возвращает:

См. также:

compare(VectorOperators.Comparison,Vector)
eq(byte)
lt(byte)

compare

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,Vector,VectorMask)

compare

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

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

Возвращает:

См. также:

blend

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

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

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

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


 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 Vector<E> b = ...;
 b.check(species);
 VectorMask<E> m = ...;
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     if (m.laneIsSet(i)) {
         ar[i] = b.lane(i);
     }
 }
 return EVector.fromArray(s, ar, 0);

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

addIndex

public abstract ByteVector addIndex(int scale)

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

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

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


 Vector<E> a = ...;
 VectorSpecies<E> species = a.species();
 ETYPE[] ar = a.toArray();
 for (int i = 0; i < ar.length; i++) {
     long d = (long)i * scale;
     if (d != (ETYPE) d)  throw ...;
     ar[i] += (ETYPE) d;
 }
 long d = (long)ar.length * scale;
 if (d != (ETYPE) d)  throw ...;
 return EVector.fromArray(s, ar, 0);

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

blend

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

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

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

blend

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

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

slice

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

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

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

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

Параметры:

origin - первый входной элемент для переноса в срез

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

Возвращает:

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

См. также:

slice

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

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

Это межлентовое действие, которое сдвигает элементы лент вперёд, из текущего вектора и второго вектора. Оба вектора можно рассматривать как объединённый «фоновый» массив длиной 2*VLENGTH, из которого извлекается срез. Результат равен выражению broadcast(0).blend(slice(origin,v1),m).

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

slice

public abstract ByteVector slice(int origin)

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


 (origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

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

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract ByteVector unslice(int origin)

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


 (origin,

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract ByteVector rearrange(VectorShuffle<Byte> m)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

rearrange

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

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

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


 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // or else: r1 = this.rearrange(s, s.laneIsValid());
 Vector<E> r2 = v.rearrange(s.wrapIndexes());
 return r2.blend(r1,s.laneIsValid());

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

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

Параметры:

s - смещение, определяющее выбор элементов из обоих входных векторов

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

Возвращает:

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

См. также:

selectFrom

public abstract ByteVector selectFrom(Vector<Byte> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

Vector.rearrange(VectorShuffle)

selectFrom

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend(byte,byte)
bitwiseBlend(byte,Vector)
bitwiseBlend(Vector,byte)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)

bitwiseBlend

public final ByteVector bitwiseBlend(byte bits, byte mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,byte,byte,VectorMask)

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,byte,Vector,VectorMask)

побитовоеСмешение

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,Vector,byte,VectorMask)

reduceLanes

public abstract byte reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

значение накопленного результата

Исключения:

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

См. также:

reduceLanes(VectorOperators.Associative,VectorMask)
add(Vector)
mul(Vector)
min(Vector)
max(Vector)
and(Vector)
or(Vector)
VectorOperators.XOR
VectorOperators.FIRST_NONZERO

reduceLanes

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes(VectorOperators.Associative)

элемент

public abstract byte lane(int i)

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

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

сЭлементом

public abstract ByteVector withLane(int i, byte e)

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

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

toArray

public final byte[] toArray()

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

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


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

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

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


 float

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

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

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

Примечание для реализации:

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


 float

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

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

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

Примечание для реализации:

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

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

Возвращает:

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

См. также:

fromByteArray

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

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

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


 var bb = ByteBuffer.wrap(a);
 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

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

fromByteArray

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

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

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


 var bb = ByteBuffer.wrap(a);
 return fromByteBuffer(species, bb, offset, bo, m);

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

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

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

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

См. также:

toIntArray()

fromArray

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

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

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

См. также:

toIntArray()

fromBooleanArray

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

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

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

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

fromBooleanArray

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

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

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

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 - массив

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

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

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

Returns:

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

Throws:

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

See Also:

toIntArray()

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:

toIntArray()

fromByteBuffer

public static ByteVector fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo)

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

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


 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

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

fromByteBuffer

public static ByteVector fromByteBuffer(VectorSpecies<Byte> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)

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

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


 ByteBuffer eb = bb.duplicate()
     .position(offset);
 byte[] ar = new byte[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = eb.get(n);
     }
 }
 ByteVector r = ByteVector.fromArray(species, ar, 0);

Implementation Note:: Аргумент порядка байтов игнорируется.
Parameters:: species - вид требуемого вектора; bb - байтовый буфер; offset - смещение в байтовом буфере; bo - предполагаемый порядок байтов; m - маска, управляющая выбором ячеек
Returns:: вектор, загруженный из байтового буфера
Throws:: IndexOutOfBoundsException - если offset+N*1 < 0 или offset+N*1 >= bb.limit() для любой ячейки N в векторе, где маска установлена

intoArray

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

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

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

Parameters:: a - массив, типа byte[]; offset - смещение в массиве
Throws:: 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. То есть, не установленные ячейки могут соответствовать индексам массива меньше нуля или за пределами массива.

Parameters:: a - массив, типа byte[]; offset - смещение в массиве; m - маска, управляющая сохранением ячеек
Throws:: 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 - смещение в карте индексов

Исключения:

См. также:

toIntArray()

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 - маска

Исключения:

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

См. также:

toIntArray()

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

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

Параметры:

a - массив

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

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

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

Исключения:

См. также:

toIntArray()

intoBooleanArray

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

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

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

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

Параметры:

a - массив

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

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

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

m - маска

Исключения:

См. также:

toIntArray()

intoByteArray

public final void intoByteArray(byte[] a, int offset, ByteOrder bo)

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

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

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


 var bb = ByteBuffer.wrap(a);
 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

Указано в:: intoByteArray в классе Vector<Byte>
Параметры:: a - массив байтов; offset - смещение в массиве; bo - желаемый порядок байтов

intoByteArray

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

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

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


 var bb = ByteBuffer.wrap(a);
 intoByteBuffer(bb, offset, bo, m);

Указано в:: intoByteArray в классе Vector<Byte>
Параметры:: a - массив байтов; offset - смещение в массиве; bo - желаемый порядок байтов; m - маска, управляющая выбором каналов

END_OF_DOCUMENT_MARKER

intoByteBuffer

public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)

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

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

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


 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

Specified by:: intoByteBuffer in class Vector<Byte>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - требуемый порядок байтов

intoByteBuffer

public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Byte> m)

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

Следующий псевдокод иллюстрирует поведение, где примитивный тип элемента не является byte, EBuffer — тип примитивного буфера, ETYPE — примитивный тип элемента, а EVector — примитивный тип вектора для этого вектора:


 EBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asEBuffer();
 ETYPE[] a = this.toArray();
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         eb.put(n, a[n]);
     }
 }

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


 ByteBuffer eb = bb.duplicate()
     .position(offset);

Specified by:: intoByteBuffer in class Vector<Byte>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - требуемый порядок байтов; m - маска, определяющая выбор лейнов

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:

Vector.eq(jdk.incubator.vector.Vector<E>)

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:

END_OF_DOCUMENT_MARKER

Проверка

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Byte> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

VectorSpecies.maskAll(boolean)

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Specified by:

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

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 - номер части результата или ноль, если ни расширение, ни сжатие не выполняются

Возвращает:

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

См. также:

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