Класс IntVector

java.lang.Object

jdk.incubator.vector.Vector<Integer>

jdk.incubator.vector.IntVector

public abstract class IntVector extends Vector<Integer>

IntVector опирается на предварительные функции платформы Java:

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

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

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

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

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

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

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

Модификатор и тип	Метод	Описание
`final IntVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final IntVector`	`add(int e)`	Добавляет этот вектор к широковещательной передаче входного скаляра.
`final IntVector`	`add(int e, VectorMask<Integer> m)`	Добавляет этот вектор к широковещательной передаче входного скаляра, выбирая элементы лейнов, управляемые маской.
`final IntVector`	`add(Vector<Integer> v)`	Добавляет этот вектор ко второму входному вектору.
`final IntVector`	`add(Vector<Integer> v, VectorMask<Integer> m)`	Добавляет этот вектор ко второму входному вектору, выбирая лейны под управлением маски.
`abstract IntVector`	`addIndex(int scale)`	Добавляет лейны этого вектора к соответствующим номерам лейнов, масштабируя их заданным константой.
`final IntVector`	`and(int e)`	Вычисляет битовое логическое конъюнкцию (`&`) этого вектора и скаляра.
`final IntVector`	`and(Vector<Integer> v)`	Вычисляет битовое логическое конъюнкцию (`&`) этого вектора и второго входного вектора.
`final IntVector`	`bitwiseBlend(int bits, int mask)`	Смешивает биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final IntVector`	`bitwiseBlend(int bits, Vector<Integer> mask)`	Смешивает биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final IntVector`	`bitwiseBlend(Vector<Integer> bits, int mask)`	Смешивает биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final IntVector`	`bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)`	Смешивает биты двух векторов под управлением третьего, который предоставляет биты маски.
`final IntVector`	`blend(int e, VectorMask<Integer> m)`	Заменяет выбранные лейны этого вектора значением скаляра под управлением маски.
`final IntVector`	`blend(long e, VectorMask<Integer> m)`	Заменяет выбранные лейны этого вектора значением скаляра под управлением маски.
`abstract IntVector`	`blend(Vector<Integer> v, VectorMask<Integer> m)`	Заменяет выбранные лейны этого вектора соответствующими лейнами из второго входного вектора под управлением маски.
`abstract IntVector`	`broadcast(int e)`	Возвращает вектор того же вида, что и этот, где все элементы лейнов установлены в примитивное значение `e`.
`abstract IntVector`	`broadcast(long e)`	Возвращает вектор того же вида, что и этот, где все элементы лейнов установлены в примитивное значение `e`.
`static IntVector`	`broadcast(VectorSpecies<Integer> species, int e)`	Возвращает вектор заданного вида, где все элементы лейнов установлены в примитивное значение `e`.
`static IntVector`	`broadcast(VectorSpecies<Integer> 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<Integer>`	`compare(VectorOperators.Comparison op, int e)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Integer>`	`compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения, в лейнах, выбранных маской.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Integer>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения, в лейнах, выбранных маской.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, Vector<Integer> v)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`abstract IntVector`	`compress(VectorMask<Integer> m)`	Сжимает элементы лейнов этого вектора, выбирая лейны под управлением заданной маски.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Integer,F> conv, int part)`	Преобразует этот вектор в вектор с той же формой и новым типом элемента, преобразуя значения лейнов из текущего `ETYPE` в новый тип лейнов (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Integer,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного вида, формы и типа элемента, преобразуя значения лейнов из текущего `ETYPE` в новый тип лейнов (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`final IntVector`	`div(int e)`	Делит этот вектор на широковещательную передачу входного скаляра.
`final IntVector`	`div(int e, VectorMask<Integer> m)`	Делит этот вектор на широковещательную передачу входного скаляра, выбирая элементы лейнов, контролируемые маской.
`final IntVector`	`div(Vector<Integer> v)`	Делит этот вектор на второй входной вектор.
`final IntVector`	`div(Vector<Integer> v, VectorMask<Integer> m)`	Делит этот вектор на второй входной вектор под управлением маски.
`final VectorMask<Integer>`	`eq(int e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Integer>`	`eq(Vector<Integer> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`abstract IntVector`	`expand(VectorMask<Integer> m)`	Расширяет элементы лейнов этого вектора под управлением заданной маски.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset)`	Загружает вектор из массива типа `int[]`, начиная со смещения.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, составленный из элементов из массива типа `int[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`	Собрать новый вектор, составленный из элементов из массива типа `int[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)`	Загружает вектор из массива типа `int[]`, начиная со смещения и используя маску.
`static IntVector`	`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти.
`static IntVector`	`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)`	Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает значение хэш-кода для вектора.
`final void`	`intoArray(int[] a, int offset)`	Сохраняет этот вектор в массив типа `int[]`, начиная со смещения.
`final void`	`intoArray(int[] a, int offset, int[] indexMap, int mapOffset)`	Рассеивает этот вектор в массив типа `int[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`final void`	`intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`	Рассеивает этот вектор в массив типа `int[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.

`final void`	`intoArray(int[] a, int offset, VectorMask<Integer> m)`	Сохраняет этот вектор в массив типа `int[]`, начиная со смещения и используя маску.
`final void`	`intoMemorySegment(MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти^{ПРЕДПРОСМОТР}, начиная со смещения, используя явный порядок байтов.
`final void`	`intoMemorySegment(MemorySegment^PREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)`	Сохраняет этот вектор в сегмент памяти^{ПРЕДПРОСМОТР}, начиная со смещения, используя явный порядок байтов и маску.
`abstract int`	`lane(int i)`	Получает элемент дорожки по индексу дорожки `i`.
`final IntVector`	`lanewise(VectorOperators.Binary op, int e)`	Комбинирует значения дорожек этого вектора со значением скаляра-расширения.
`final IntVector`	`lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)`	Комбинирует значения дорожек этого вектора со значением скаляра-расширения, с выбором элементов дорожек, управляемым маской.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e)`	Комбинирует значения дорожек этого вектора со значением скаляра-расширения.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)`	Комбинирует соответствующие значения дорожек этого вектора со значениями второго входного вектора, с выбором элементов дорожек, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v)`	Комбинирует соответствующие значения дорожек этого вектора со значениями второго входного вектора.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)`	Комбинирует соответствующие значения дорожек этого вектора со значениями второго входного вектора, с выбором элементов дорожек, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2)`	Комбинирует значения дорожек этого вектора со значениями двух скаляров-расширений.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)`	Комбинирует значения дорожек этого вектора со значениями двух скаляров-расширений, с выбором элементов дорожек, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)`	Комбинирует значения дорожек этого вектора со значениями другого вектора и скаляра-расширения.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)`	Комбинирует значения дорожек этого вектора со значениями другого вектора и скаляра-расширения, с выбором элементов дорожек, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)`	Комбинирует значения дорожек этого вектора со значениями другого вектора и скаляра-расширения.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)`	Комбинирует значения дорожек этого вектора со значениями другого вектора и скаляра-расширения, с выбором элементов дорожек, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)`	Комбинирует соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)`	Комбинирует соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов, с выбором элементов дорожек, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операции над значениями дорожек этого вектора.
`abstract IntVector`	`lanewise(VectorOperators.Unary op, VectorMask<Integer> m)`	Осуществляет операции над значениями дорожек этого вектора, с выбором элементов дорожек, управляемых маской.
`final VectorMask<Integer>`	`lt(int e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Integer>`	`lt(Vector<Integer> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Integer>`	`maskAll(boolean bit)`	Возвращает маску того же типа, что и этот вектор, где каждая дорожка установлена или сброшена в соответствии с заданным одиночным булевым значением, которое транслируется на все дорожки.
`final IntVector`	`max(int e)`	Вычисляет большее из этого вектора и расширенного входного скаляра.
`final IntVector`	`max(Vector<Integer> v)`	Вычисляет большее из этого вектора и второго входного вектора.
`final IntVector`	`min(int e)`	Вычисляет меньшее из этого вектора и расширенного входного скаляра.
`final IntVector`	`min(Vector<Integer> v)`	Вычисляет меньшее из этого вектора и второго входного вектора.
`final IntVector`	`mul(int e)`	Умножает этот вектор на расширенный входной скаляр.
`final IntVector`	`mul(int e, VectorMask<Integer> m)`	Умножает этот вектор на расширенный входной скаляр, выбирая элементы дорожек, управляемые маской.
`final IntVector`	`mul(Vector<Integer> v)`	Умножает этот вектор на второй входной вектор.
`final IntVector`	`mul(Vector<Integer> v, VectorMask<Integer> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final IntVector`	`neg()`	Изменяет знак этого вектора.
`final IntVector`	`not()`	Вычисляет побитовое логическое дополнение (`~`) этого вектора.
`final IntVector`	`or(int e)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и скаляра.
`final IntVector`	`or(Vector<Integer> v)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> m)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определённого перемешивания.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> s, Vector<Integer> v)`	Переупорядочивает элементы дорожек двух векторов, выбирая дорожки под управлением определённого перемешивания, используя как обычные, так и исключительные индексы в перемешивании для управления данными.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определённого перемешивания и маски.
`abstract int`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное со всех дорожек этого вектора.
`abstract int`	`reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)`	Возвращает значение, накопленное с выбранных дорожек этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и содержимого, но с типом дорожки `byte`, где байты извлекаются с дорожек в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `double`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `float`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `int`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `long`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `short`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract IntVector`	`selectFrom(Vector<Integer> v)`	Используя значения индексов, хранящиеся на дорожках этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`abstract IntVector`	`selectFrom(Vector<Integer> s, VectorMask<Integer> m)`	Вырезает сегмент смежных дорожек, начиная с заданной `origin` дорожки в текущем векторе.

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

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Integer> SPECIES_64

Species representing IntVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Integer> SPECIES_128

Species representing IntVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Integer> SPECIES_256

Species representing IntVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Integer> SPECIES_512

Species representing IntVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Integer> SPECIES_MAX

Species representing IntVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Integer> SPECIES_PREFERRED

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

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

zero

public static IntVector zero(VectorSpecies<Integer> species)

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

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

broadcast

public abstract IntVector broadcast(int e)

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

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

API Note:

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

public static IntVector broadcast(VectorSpecies<Integer> species, int e)

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

Параметры:

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

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

Возвращает:

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

См. также:

broadcast

public abstract IntVector broadcast(long e)

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

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

Указано в:

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

API Note:

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

public static IntVector broadcast(VectorSpecies<Integer> species, long e)

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Unary op, VectorMask<Integer> m)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Binary op, int e)

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)

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

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)

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

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

add

public final IntVector add(Vector<Integer> v)

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

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

Унаследовано от:

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

Параметры:

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

Возвращает:

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

См. также:

add

public final IntVector add(int e)

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

Параметры:

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

Возвращает:

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

См. также:

add

public final IntVector add(Vector<Integer> v, VectorMask<Integer> m)

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

Унаследовано от:

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

Параметры:

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

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

Возвращает:

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

См. также:

add

public final IntVector add(int e, VectorMask<Integer> m)

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

Parameters:

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

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

Returns:

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

See Also:

sub

public final IntVector sub(Vector<Integer> v)

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

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

Specified by:

sub in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

sub

public final IntVector sub(int e)

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

Parameters:

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

Returns:

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

See Also:

sub

public final IntVector sub(Vector<Integer> v, VectorMask<Integer> m)

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

Specified by:

sub in class Vector<Integer>

Parameters:

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

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

Returns:

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

See Also:

sub

public final IntVector sub(int e, VectorMask<Integer> m)

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final IntVector mul(Vector<Integer> v)

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

Specified by:

mul in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

mul

public final IntVector mul(int e)

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

Parameters:

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

Returns:

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

See Also:

mul

public final IntVector mul(Vector<Integer> v, VectorMask<Integer> m)

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

Specified by:

mul in class Vector<Integer>

Parameters:

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

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

Returns:

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

See Also:

умнож

public final IntVector mul(int e, VectorMask<Integer> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

деление

public final IntVector div(Vector<Integer> v)

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

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

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

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

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

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


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

деление

public final IntVector div(int e)

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

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

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


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

деление

public final IntVector div(Vector<Integer> v, VectorMask<Integer> m)

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

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

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

деление

public final IntVector div(int e, VectorMask<Integer> m)

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

мин

public final IntVector min(Vector<Integer> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

мин

public final IntVector min(int e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final IntVector max(Vector<Integer> v)

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

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

Указано:

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

Параметры:

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

Возвращает:

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

См. также:

max

public final IntVector max(int e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final IntVector and(Vector<Integer> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final IntVector and(int e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final IntVector or(Vector<Integer> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final IntVector or(int e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final IntVector neg()

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

Указано:

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

Возвращает:

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

См. также:

abs

public final IntVector abs()

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

Указано:

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

Возвращает:

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

См. также:

not

public final IntVector not()

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

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

Возвращает:

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

См. также:

eq

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Integer> eq(int e)

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

Параметры:

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

Возвращает:

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

См. также:

lt

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Integer> lt(int e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, int e)

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

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

Параметры:

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

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

Возвращает:

См. также:

compare

public final VectorMask<Integer> compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare

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

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

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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

Specified by:

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

Parameters:

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

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

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

Returns:

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

See Also:

blend

public abstract IntVector blend(Vector<Integer> v, VectorMask<Integer> 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);

Specified by:: blend в классе Vector<Integer>
Parameters:: v - второй входной вектор, содержащий значения заменяемых элементов; m - маска, контролирующая выбор элементов из второго входного вектора
Returns:: результат смешивания элементов этого вектора с элементами второго входного вектора

addIndex

public abstract IntVector 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);

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

blend

public final IntVector blend(int e, VectorMask<Integer> m)

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

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

blend

public final IntVector blend(long e, VectorMask<Integer> m)

Specified by:: blend в классе Vector<Integer>
Parameters:: e - скалярный ввод, содержащий значение заменяемого элемента; m - маска, контролирующая выбор элемента скаляра
Returns:: результат смешивания элементов этого вектора со скалярным значением

slice

public abstract IntVector slice(int origin, Vector<Integer> v1)

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

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

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

Parameters:

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

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

Returns:

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

See Also:

slice

public final IntVector slice(int origin, Vector<Integer> w, VectorMask<Integer> m)

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

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

Specified by:

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

Parameters:

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

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

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

Returns:

See Also:

slice

public abstract IntVector slice(int origin)

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


 (origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

public abstract IntVector unslice(int origin, Vector<Integer> 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<Integer>

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

public abstract IntVector unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract IntVector unslice(int origin)

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


 (origin,

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> m)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> s, VectorMask<Integer> 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<Integer>

Параметры:

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

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

Возвращает:

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

См. также:

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

public abstract IntVector rearrange(VectorShuffle<Integer> s, Vector<Integer> 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<Integer>

Параметры:

s - перемешивание, контролирующее выбор проходов из обоих входных векторов

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

Возвращает:

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

См. также:

сжать

public abstract IntVector compress(VectorMask<Integer> m)

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

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

расширить

public abstract IntVector expand(VectorMask<Integer> m)

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

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

выбратьИз

public abstract IntVector selectFrom(Vector<Integer> v)

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

Определено:

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

Параметры:

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

Возвращает:

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

См. также:

выбратьИз

public abstract IntVector selectFrom(Vector<Integer> s, VectorMask<Integer> m)

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

Определено:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

public final IntVector bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

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

public final IntVector bitwiseBlend(int bits, int mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

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

public final IntVector bitwiseBlend(int bits, Vector<Integer> mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

public final IntVector bitwiseBlend(Vector<Integer> bits, int mask)

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

Parameters:

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

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

Returns:

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

See Also:

reduceLanes

public abstract int reduceLanes(VectorOperators.Associative op)

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

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

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

Parameters:

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

Returns:

аккумулированный результат

Throws:

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

See Also:

reduceLanes

public abstract int reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)

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

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

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

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

Parameters:

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

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

Returns:

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

Throws:

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

See Also:

lane

public abstract int lane(int i)

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

Parameters:: i - индекс элемента
Returns:: элемент элемента на индексе элемента i
Throws:: IllegalArgumentException - если индекс выходит за пределы диапазона (< 0 || >= length())

withLane

public abstract IntVector withLane(int i, int e)

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

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

toArray

public final int[] toArray()

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

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


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

Specified by:

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

Returns:

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

See Also:

toIntArray

public final int[] toIntArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toLongArray

public final long[] toLongArray()

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


 float

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

toDoubleArray

public final double[] toDoubleArray()

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

Указано в:

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

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

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

Возвращает:

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

См. также:

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset)

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

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

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)

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

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

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

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

См. также:

fromArray

public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

См. также:

fromMemorySegment

public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)

Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти. Байты объединяются в примитивные элементы полос в соответствии с указанным порядком байтов. Вектор упорядочивается по полосам в соответствии с порядком памяти.

Этот метод ведет себя так, как если бы он возвращал результат вызова fromMemorySegment()^{ПРЕДПРОСМОТР} следующим образом:


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

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

fromMemorySegment

public static IntVector fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)

Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти и используя маску. Полосы, где маска не установлена, заполняются значениями по умолчанию int (ноль). Байты объединяются в примитивные элементы полос в соответствии с указанным порядком байтов. Вектор упорядочивается по полосам в соответствии с порядком памяти.

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


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

Примечание реализации:: Эта операция, вероятно, будет более эффективной, если указанный порядок байтов совпадает с родным порядком платформы, так как этому методу не придётся переупорядочивать байты значений полос.
Параметры:: species - вид желаемого вектора; ms - сегмент памяти; offset - смещение в сегменте памяти; bo - желаемый порядок байтов; m - маска, контролирующая выбор полос
Возвращает:: вектор, загруженный из сегмента памяти
Исключения:: IndexOutOfBoundsException - если offset+N*4 < 0 или offset+N*4 >= ms.byteSize() для любой полосы N в векторе, где маска установлена; IllegalArgumentException - если сегмент памяти — сегмент кучи, который не поддерживает массив byte[].; IllegalStateException - если сессия сегмента памяти не активна или если доступ происходит из потока, отличного от потока, владеющего сессией.
С:: 19

intoArray

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

Записывает этот вектор в массив типа int[], начиная с определённого смещения.

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

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

See Also:

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

intoMemorySegment

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

Записывает этот вектор в сегмент памяти^{ПРОСМОТР}, начиная со смещения, используя явное порядок байтов.

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

Этот метод ведет себя так, как будто он вызывает intoMemorySegment()^{ПРОСМОТР} следующим образом:


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

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

intoMemorySegment

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

Записывает этот вектор в сегмент памяти^{ПРОСМОТР}, начиная со смещения, используя явное порядок байтов и маску.

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Specified by:

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

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

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

See Also:

species

public final VectorSpecies<Integer> species()

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

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

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

check

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

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

Returns:

тот же вектор

See Also:

check

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

elementType - требуемый тип канала

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Integer> maskAll(boolean bit)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

public final <F> Vector<F> convert(VectorOperators.Conversion<Integer,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:

Преобразование формы

public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Integer,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 - номер части результата или ноль, если ни расширение, ни сокращение не применяются

Возвращает:

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

См. также:

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

protected final Object getPayload()

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