Класс IntVector

java.lang.Object

jdk.incubator.vector.Vector<Integer>

jdk.incubator.vector.IntVector

public abstract class IntVector extends Vector<Integer>

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

`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегменте памяти памяти, начиная с определенного смещения, используя явное порядок байтов.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)`	Сохраняет этот вектор в сегменте памяти памяти, начиная с определенного смещения, используя явное порядок байтов и маску.
`abstract int`	`lane(int i)`	Получает элемент канала в индексе канала `i`
`final IntVector`	`lanewise(VectorOperators.Binary op, int e)`	Комбинирует значения каналов этого вектора со значением широковещательного скаляра.
`final IntVector`	`lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)`	Комбинирует значения каналов этого вектора со значением широковещательного скаляра, с выбором элементов канала, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e)`	Комбинирует значения каналов этого вектора со значением широковещательного скаляра.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)`	Комбинирует соответствующие значения каналов этого вектора со значениями второго входного вектора, с выбором элементов канала, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v)`	Комбинирует соответствующие значения каналов этого вектора со значениями второго входного вектора.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)`	Комбинирует соответствующие значения каналов этого вектора со значениями второго входного вектора, с выбором элементов канала, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2)`	Комбинирует значения каналов этого вектора со значениями двух широковещательных скаляров.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)`	Комбинирует значения каналов этого вектора со значениями двух широковещательных скаляров, с выбором элементов канала, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)`	Комбинирует значения каналов этого вектора со значениями другого вектора и широковещательного скаляра.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)`	Комбинирует значения каналов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов канала, управляемых маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)`	Комбинирует значения каналов этого вектора со значениями другого вектора и широковещательного скаляра.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)`	Комбинирует значения каналов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов канала, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)`	Комбинирует соответствующие значения каналов этого вектора с каналами второго и третьего входных векторов.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)`	Комбинирует соответствующие значения каналов этого вектора с каналами второго и третьего входных векторов, с выбором элементов канала, управляемых маской.
`abstract IntVector`	`lanewise(VectorOperators.Unary op)`	Операции над значениями каналов этого вектора.
`abstract IntVector`	`lanewise(VectorOperators.Unary op, VectorMask<Integer> m)`	Операции над значениями каналов этого вектора, с выбором элементов канала, управляемых маской.
`final VectorMask<Integer>`	`lt(int e)`	Проверяет, меньше ли этот вектор, чем входной скаляр.
`final VectorMask<Integer>`	`lt(Vector<Integer> v)`	Проверяет, меньше ли этот вектор, чем другой входной вектор.
`final VectorMask<Integer>`	`maskAll(boolean bit)`	Возвращает маску той же спецификации, что и этот вектор, где каждый канал установлен или сброшен в соответствии с заданным одиночным булевым значением, которое транслируется во все каналы.
`final IntVector`	`max(int e)`	Вычисляет большее из этого вектора и широковещательной трансляции входного скаляра.
`final IntVector`	`max(Vector<Integer> v)`	Вычисляет большее из этого вектора и второго входного вектора.
`final IntVector`	`min(int e)`	Вычисляет меньшее из этого вектора и широковещательной трансляции входного скаляра.
`final IntVector`	`min(Vector<Integer> v)`	Вычисляет меньшее из этого вектора и второго входного вектора.
`final IntVector`	`mul(int e)`	Умножает этот вектор на широковещательную трансляцию входного скаляра.
`final IntVector`	`mul(int e, VectorMask<Integer> m)`	Умножает этот вектор на широковещательную трансляцию входного скаляра, выбирая элементы канала, управляемые маской.
`final IntVector`	`mul(Vector<Integer> v)`	Умножает этот вектор на второй входной вектор.
`final IntVector`	`mul(Vector<Integer> v, VectorMask<Integer> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final IntVector`	`neg()`	Изменяет знак этого вектора.
`final IntVector`	`not()`	Вычисляет побитовое логическое отрицание (`~`) этого вектора.
`final IntVector`	`or(int e)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и скаляра.
`final IntVector`	`or(Vector<Integer> v)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> shuffle)`	Переупорядочивает элементы канала этого вектора, выбирая каналы под управлением определенного перемешивания.
`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> v1, Vector<Integer> v2)`	Используя значения, хранящиеся в каналах этого вектора, собирайте значения, хранящиеся во втором векторе `v1` и третьем векторе `v2`.
`abstract IntVector`	`selectFrom(Vector<Integer> s, VectorMask<Integer> m)`	Вырезает фрагмент смежных каналов, начиная с заданного `origin` канала в текущем векторе.

`abstract IntVector`	`slice(int origin, Vector<Integer> v1)`	Вырезает сегмент смежных полос, начиная с указанной `origin` полосы в текущем векторе и продолжая (по необходимости) в непосредственно следующем векторе.
`final IntVector`	`slice(int origin, Vector<Integer> w, VectorMask<Integer> m)`	Вырезает сегмент смежных полос под управлением маски, начиная с указанной `origin` полосы в текущем векторе и продолжая (по необходимости) в непосредственно следующем векторе.
`final VectorSpecies<Integer>`	`species()`	Возвращает вид этого вектора.
`final IntVector`	`sub(int e)`	Вычитает входной скаляр из этого вектора.
`final IntVector`	`sub(int e, VectorMask<Integer> m)`	Вычитает входной скаляр из этого вектора под управлением маски.
`final IntVector`	`sub(Vector<Integer> v)`	Вычитает второй входной вектор из этого вектора.
`final IntVector`	`sub(Vector<Integer> v, VectorMask<Integer> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Integer>`	`test(VectorOperators.Test op)`	Проверяет полосы этого вектора в соответствии с заданной операцией.
`abstract VectorMask<Integer>`	`test(VectorOperators.Test op, VectorMask<Integer> m)`	Проверяет выбранные полосы этого вектора в соответствии с заданной операцией.
`final int[]`	`toArray()`	Возвращает массив типа `int[]`, содержащий все значения полос.
`final double[]`	`toDoubleArray()`	Возвращает массив типа `double[]`, содержащий все значения полос, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив типа `int[]`, содержащий все значения полос, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает строковое представление этого вектора в формате `"[0,1,2...]"`, отражающее значения полос этого вектора в порядке полос.
`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, compare, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle

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

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

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

SPECIES_64

public static final VectorSpecies<Integer> SPECIES_64

Species representing IntVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Integer> SPECIES_128

Species representing IntVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Integer> SPECIES_256

Species representing IntVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Integer> SPECIES_512

Species representing IntVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Integer> SPECIES_MAX

Species representing IntVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Integer> SPECIES_PREFERRED

Preferred species for IntVectors. A preferred species is a species of maximal bit-size for the platform.

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

zero

public static IntVector zero(VectorSpecies<Integer> species)

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

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

broadcast

public abstract IntVector broadcast(int e)

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

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

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

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

Параметры:

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

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

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

См. также:

broadcast

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

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

Параметры:

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

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

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

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

См. также:

broadcast

public abstract IntVector broadcast(long e)

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

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

Указано в:

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

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

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

Параметры:

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

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

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

См. также:

broadcast

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

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

Параметры:

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

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

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

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

Исключения:

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

См. также:

lanewise

public abstract IntVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

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

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

Возвращает:

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

Изначает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Изначает:

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

См. также:

lanewise

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Изначает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

add

public final IntVector add(Vector<Integer> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

add

public final IntVector add(int e)

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

Параметры:

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

Возвращает:

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

См. также:

add

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

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

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

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

Параметры:

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

m - маска для выбора элементов

Возвращает:

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

См. также:

add

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

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

Parameters:

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

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

Returns:

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

See Also:

sub

public final IntVector sub(Vector<Integer> v)

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

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

Specified by:

sub in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

sub

public final IntVector sub(int e)

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

Parameters:

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

Returns:

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

See Also:

sub

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

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

Specified by:

sub in class Vector<Integer>

Parameters:

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

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

Returns:

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

See Also:

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final IntVector mul(Vector<Integer> v)

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

Specified by:

mul in class Vector<Integer>

Parameters:

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

Returns:

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

See Also:

mul

public final IntVector mul(int e)

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

Parameters:

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

Returns:

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

See Also:

mul

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

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

Specified by:

mul in class Vector<Integer>

Parameters:

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

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

Returns:

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

See Also:

умн

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

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

Параметры:

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

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

Возвращает:

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

См. также:

дел

public final IntVector div(Vector<Integer> v)

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

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

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

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

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

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


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

дел

public final IntVector div(int e)

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

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

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


 ArithmeticException

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

Параметры:

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

Возвращает:

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

См. также:

дел

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

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

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

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

дел

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

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

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

Возвращает:

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

См. также:

max

public final IntVector max(Vector<Integer> v)

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

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

Specified by:

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

Параметры:

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

Возвращает:

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

См. также:

max

public final IntVector max(int e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final IntVector and(Vector<Integer> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final IntVector and(int e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final IntVector or(Vector<Integer> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final IntVector or(int e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final IntVector neg()

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

Specified by:

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

Возвращает:

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

См. также:

abs

public final IntVector abs()

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

Specified by:

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

Возвращает:

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

См. также:

не

public final IntVector not()

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

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

Возвращает:

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

См. также:

равно

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

равно

public final VectorMask<Integer> eq(int e)

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

Параметры:

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

Возвращает:

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

См. также:

меньше

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

меньше

public final VectorMask<Integer> lt(int e)

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

Параметры:

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

Возвращает:

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

См. также:

проверка

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

проверка

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

сравнение

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

сравнение

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

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

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

Параметры:

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

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

Возвращает:

См. также:

сравнение

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

END_OF_DOCUMENT_MARKER

compare

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

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

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

Specified by:

compare in class Vector<Integer>

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

Specified by:

compare in class Vector<Integer>

Parameters:

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

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

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

Returns:

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

See Also:

blend

public abstract IntVector blend(Vector<Integer> v, VectorMask<Integer> m)

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

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

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


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

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

addIndex

public abstract IntVector addIndex(int scale)

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

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

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


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

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

blend

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

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

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

blend

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

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

slice

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

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

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

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

Parameters:

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

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

Returns:

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

See Also:

slice

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

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

Specified by:

slice in class Vector<Integer>

Parameters:

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

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

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

Returns:

See Also:

slice

public abstract IntVector slice(int origin)

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


 (origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

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

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

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

Определено:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

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

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

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

Определено:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract IntVector unslice(int origin)

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


 (origin,

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

Определено:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> shuffle)

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

Определено:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract IntVector rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)

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

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


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

Определено:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

public abstract IntVector rearrange(VectorShuffle<Integer> s, Vector<Integer> v)

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

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


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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Компрессия

public abstract IntVector compress(VectorMask<Integer> m)

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

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

Расширение

public abstract IntVector expand(VectorMask<Integer> m)

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

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

selectFrom

public abstract IntVector selectFrom(Vector<Integer> v)

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

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

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

Параметры:

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

Возвращает:

перестановку элементов проходов v

См. также:

selectFrom

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

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

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

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

Параметры:

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

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

Возвращает:

перестановку элементов проходов v

См. также:

selectFrom

public abstract IntVector selectFrom(Vector<Integer> v1, Vector<Integer> v2)

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

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

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

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

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

Параметры:

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

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

Возвращает:

перестановку элементов проходов v1 и v2

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

public final IntVector bitwiseBlend(int bits, int mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

reduceLanes

public abstract int reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

накопленный результат

Исключения:

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

См. также:

reduceLanes

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

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

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

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

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

Параметры:

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

lane

public abstract int lane(int i)

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

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

сLane

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

См. также:

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

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

См. также:

fromArray

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

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

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

Parameters:

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

a - массив

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

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

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

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

Returns:

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

Throws:

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

See Also:

fromMemorySegment

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

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

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


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

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

fromMemorySegment

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

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

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


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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

intoMemorySegment

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

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

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

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


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

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

intoMemorySegment

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

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

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Specified by:

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

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

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

See Also:

species

public final VectorSpecies<Integer> species()

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

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

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

check

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

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

Returns:

тот же вектор

See Also:

check

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

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

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

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

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

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

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

Параметры:

elementType - требуемый тип прохода

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Integer> maskAll(boolean bit)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

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 мантиссы.

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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


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

Указано:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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