Класс IntVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

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

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.IntVector

public abstract class IntVector extends Vector<E>

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

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

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

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

Модификатор и тип	Метод	Описание
`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)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`final VectorMask<Integer>`	`compare(VectorOperators.Comparison op, Vector<Integer> v, 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)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`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`	`fromByteArray(VectorSpecies<Integer> species, byte[] a, int offset, ByteOrder bo)`	Загружает вектор из массива байтов, начиная со смещения.
`static IntVector`	`fromByteArray(VectorSpecies<Integer> species, byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m)`	Загружает вектор из массива байтов, начиная со смещения и используя маску.
`static IntVector`	`fromByteBuffer(VectorSpecies<Integer> species, ByteBuffer bb, int offset, ByteOrder bo)`	Загружает вектор из буфера байтов, начиная со смещения в буфер байтов.
`static IntVector`	`fromByteBuffer(VectorSpecies<Integer> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Integer> m)`	Загружает вектор из буфера байтов, начиная со смещения в буфер байтов и используя маску.
`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`	`intoByteArray(byte[] a, int offset, ByteOrder bo)`	Сохраняет этот вектор в массив байтов, начиная со смещения, с явным порядком байтов.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Integer> m)`	Сохраняет этот вектор в массив байтов, начиная со смещения, с явным порядком байтов и маской.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)`	Сохраняет этот вектор в буфер байтов, начиная со смещения, с явным порядком байтов.
`final void`	`intoByteBuffer(ByteBuffer bb, int 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)`	Объединяет соответствующие значения дорожек этого вектора со значениями второй входной векторной величины.
`final 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)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов с выбором элементов дорожек, контролируемым маской.
`abstract IntVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операции над значениями дорожек этого вектора.
`final 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)`	Используя значения индексов, хранящиеся в дорожках этого вектора, собирает значения, хранящиеся во втором векторе, под управлением маски.
`abstract IntVector`	`slice(int origin)`	Вырезает сегмент смежных дорожек, начиная с заданной `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)`	Проверяет линии этого вектора в соответствии с заданной операцией.
`final 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...]"`, отображающее значения линий этого вектора в порядке линий.
`abstract IntVector`	`unslice(int origin)`	Инвертирует 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)`	Инвертирует slice(), вставляя (под управлением маски) текущий вектор как срез в другой «фоновый» вектор ввода, который рассматривается как один из входов в гипотетической последующей `slice()` операции.
`final FloatVector`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом линии, который является типом с плавающей точкой.
`final IntVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом линии, который не является типом с плавающей точкой.
`abstract IntVector`	`withLane(int i, int e)`	Заменяет элемент линии этого вектора в индексе линии `i` значением `e`.
`static IntVector`	`zero(VectorSpecies<Integer> species)`	Возвращает вектор заданного вида, где все элементы линий установлены в ноль — значение по умолчанию для примитивного типа.

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

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

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

getPayload

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

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

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

SPECIES_64

public static final VectorSpecies<Integer> SPECIES_64

Species, представляющий IntVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Integer> SPECIES_128

Species, представляющий IntVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Integer> SPECIES_256

Species, представляющий IntVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Integer> SPECIES_512

Species, представляющий IntVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Integer> SPECIES_MAX

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

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

broadcast

public abstract IntVector broadcast(int e)

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

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

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

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

Параметры:

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

Возвращаемое значение:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращаемое значение:

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

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

Параметры:

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

Возвращаемое значение:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращаемое значение:

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

Исключения:

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

Возвращаемое значение:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращаемое значение:

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращаемое значение:

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

См. также:

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

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,int,VectorMask)

lanewise

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

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

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

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

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

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

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

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

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

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

lanewise

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

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

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

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

add

public final IntVector add(Vector<Integer> v)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

add(int)

add

public final IntVector add(int e)

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

Параметры:

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

Возвращает:

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

См. также:

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

add

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

add(int,VectorMask)

add

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

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

Parameters:

e - передаваемый скаляр

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

Returns:

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

See Also:

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

sub

public final IntVector sub(Vector<Integer> v)

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

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

Specified by:

sub in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

sub(int)

sub

public final IntVector sub(int e)

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

Parameters:

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

Returns:

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

See Also:

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

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

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

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

mul

public final IntVector mul(Vector<Integer> v)

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

Specified by:

mul in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

mul(int)

mul

public final IntVector mul(int e)

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

Parameters:

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

Returns:

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

See Also:

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

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:

mul(int,VectorMask)

mul

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

div

public final IntVector div(Vector<Integer> v)

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

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

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

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

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

Если существует делитель равный нулю,


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

div

public final IntVector div(int e)

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

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

Если существует делитель равный нулю,


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

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

div

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

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

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

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

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

Если существует делитель равный нулю,


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

div(int,VectorMask)

div

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

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

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

Если существует делитель равный нулю,


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

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

min

public final IntVector min(Vector<Integer> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final IntVector min(int e)

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

Параметры:

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

Возвращает:

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

См. также:

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

max

public final IntVector max(Vector<Integer> v)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

max

public final IntVector max(int e)

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

Parameters:

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

Returns:

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

See Also:

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

and

public final IntVector and(Vector<Integer> v)

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

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

Parameters:

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

Returns:

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

See Also:

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

and

public final IntVector and(int e)

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

Parameters:

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

Returns:

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

See Also:

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

or

public final IntVector or(Vector<Integer> v)

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

Parameters:

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

Returns:

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

See Also:

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

or

public final IntVector or(int e)

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

Parameters:

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

Returns:

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

See Also:

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

neg

public final IntVector neg()

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

Specified by:

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

Returns:

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

See Also:

abs

public final IntVector abs()

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

Specified by:

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

Returns:

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

See Also:

not

public final IntVector not()

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

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

Returns:

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

See Also:

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

eq

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

eq

public final VectorMask<Integer> eq(int e)

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

Parameters:

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

Returns:

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

See Also:

compare(VectorOperators.Comparison,int)

lt

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

lt

public final VectorMask<Integer> lt(int e)

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

Parameters:

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

Returns:

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

See Also:

compare(VectorOperators.Comparison,int)

test

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

test

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

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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

Vector.test(VectorOperators.Test)

compare

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

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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

Specified by:

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

Parameters:

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

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

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

Returns:

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

See Also:

Vector.compare(VectorOperators.Comparison, Vector)

compare

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

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

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

Parameters:

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

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

Returns:

See Also:

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

compare

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,Vector,VectorMask)

compare

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

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

Возвращает:

См. также:

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

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

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

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

blend

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

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

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

blend

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

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

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, соответственно.

Параметры:

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

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

Возвращает:

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

См. также:

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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

Возвращает:

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

См. также:

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

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

Возвращает:

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

См. также:

selectFrom

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

См. также:

Vector.rearrange(VectorShuffle)

selectFrom

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 - побитовая маска для включения слияния входных битов

Возвращает:

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

См. также:

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

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

public final IntVector bitwiseBlend(int bits, int mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

reduceLanes

public abstract int reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

полученное значение

Исключение:

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

См. также:

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

reduceLanes

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

Исключение:

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

См. также:

reduceLanes(VectorOperators.Associative)

lane

public abstract int lane(int i)

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

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

withLane

public abstract IntVector withLane(int i, int e)

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

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

toArray

public final int[] toArray()

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

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


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

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

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


 float

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

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

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


 float

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

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

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

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

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

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

Возвращает:

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

См. также:

fromByteArray

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

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

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


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

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

fromByteArray

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

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

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


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

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

fromArray

public static 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 в векторе

См. также:

toIntArray()

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 - маска, управляющая выбором полос

Возвращает:

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

Исключение:

См. также:

toIntArray()

fromByteBuffer

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

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

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


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

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

fromByteBuffer

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

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

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


 IntBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asIntBuffer();
 int[] ar = new int[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = eb.get(n);
     }
 }
 IntVector r = IntVector.fromArray(species, ar, 0);

Примечание по реализации:: Эта операция, вероятно, будет более эффективной, если указанный порядок байтов совпадает с родным порядком платформы, так как этому методу не потребуется переупорядочивать байты значений разрядов.
Параметры:: species - вид желаемого вектора; bb - буфер байтов; offset - смещение в буфере байтов; bo - предполагаемый порядок байтов; m - маска, управляющая выбором разрядов
Возвращает:: вектор, загруженный из буфера байтов
Исключение:: IndexOutOfBoundsException - если offset+N*4 < 0 или offset+N*4 >= bb.limit() для любого разряда N в векторе, где маска установлена

intoArray

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

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

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

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

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

Параметры:

a - массив

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

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

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

Исключение:

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

См. также:

toIntArray()

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

Параметры:

a - массив

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

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

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

m - маска

Исключение:

См. также:

toIntArray()

intoByteArray

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

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

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

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


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

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

intoByteArray

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

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

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


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

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

intoByteBuffer

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

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

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


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

Указано в:: intoByteBuffer в классе Vector<Integer>
Параметры:: bb - буфер байтов; offset - смещение в массиве; bo - предполагаемый порядок байтов

intoByteBuffer

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

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

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


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

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


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

Указано в:: intoByteBuffer в классе Vector<Integer>
Параметры:: bb - буфер байтов; offset - смещение в массиве; bo - предполагаемый порядок байтов; m - маска, управляющая выбором разрядов

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Указано в:

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

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

hashCode

public final int hashCode()

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

Указано в:

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

Возвращает:

хэш-код этого вектора

См. также:

species

public final VectorSpecies<Integer> species()

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

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

Указано в:: species в классе Vector<E>
Возвращает:: вид этого вектора

check

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

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

Указано в:

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

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

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

Параметры:

elementType - требуемый тип элементов

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Integer> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

VectorSpecies.maskAll(boolean)

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

Определено:: reinterpretAsDoubles в классе Vector<E>
Возвращает:: вектор 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).

Определено:

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

Типы параметров:

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)

Удобный метод для преобразования вектора из одного типа элементов в другой, переформировывая, если размеры элементов меняются. Этот метод возвращает значение этого выражения: convertShape(conv,rsp,part), где conv равно VectorOperators.Conversion.ofCast(E.class,F.class).

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

Определено:

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

Типы параметров:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

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

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

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

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


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

Указано в:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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