Класс 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`; байты извлекаются из полос в порядке от младшего к старшему.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `double`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `float`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `int`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `long`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `short`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`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)`	Используя значения индексов, хранящиеся в полосах этого вектора, собирает значения из второго вектора под управлением маски.
`abstract IntVector`	`slice(int origin)`	Извлекает сегмент смежных полос, начиная с заданной полосы `origin` в текущем векторе.
`abstract IntVector`	`slice(int origin, Vector<Integer> v1)`	Извлекает сегмент смежных полос, начиная с заданной полосы `origin` в текущем векторе и при необходимости продолжая его в непосредственно следующем векторе.
`final IntVector`	`slice(int origin, Vector<Integer> w, VectorMask<Integer> m)`	Извлекает сегмент смежных полос под управлением маски, начиная с заданной полосы `origin` в текущем векторе и при необходимости продолжая его в непосредственно следующем векторе.
`final VectorSpecies<Integer>`	`species()`	Возвращает вид этого вектора.
`final IntVector`	`sub(int e)`	Вычитает входное скалярное значение из этого вектора.
`final IntVector`	`sub(int e, VectorMask<Integer> m)`	Вычитает входное скалярное значение из этого вектора под управлением маски.
`final IntVector`	`sub(Vector<Integer> v)`	Вычитает второй входной вектор из этого вектора.
`final IntVector`	`sub(Vector<Integer> v, VectorMask<Integer> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Integer>`	`test(VectorOperators.Test op)`	Проверяет полосы этого вектора согласно заданной операции.
`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()`	Возвращает массив `long[]`, содержащий значения всех полос, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора в формате `"[0,1,2...]"` со значениями полос этого вектора в порядке следования полос.
`abstract IntVector`	`unslice(int origin)`	Выполняет обратное преобразование среза, вставляя текущий вектор как срез в «фоновый» вход, содержащий нулевые значения полос.
`abstract IntVector`	`unslice(int origin, Vector<Integer> w, int part)`	Выполняет обратное преобразование среза, вставляя текущий вектор как срез в другой «фоновый» входной вектор, который рассматривается как один из входов для гипотетической последующей операции `slice()`.
`abstract IntVector`	`unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)`	Выполняет обратное преобразование среза, вставляя (под управлением маски) текущий вектор как срез в другой «фоновый» входной вектор, который рассматривается как один из входов для гипотетической последующей операции `slice()`.
`final FloatVector`	`viewAsFloatingLanes()`	Интерпретирует этот вектор как вектор той же формы, длины и содержимого, но с типом полос с плавающей точкой.
`final IntVector`	`viewAsIntegralLanes()`	Интерпретирует этот вектор как вектор той же формы, длины и содержимого, но с типом полос, не являющимся типом с плавающей точкой.
`abstract IntVector`	`withLane(int i, int e)`	Заменяет элемент полосы этого вектора с индексом `i` значением `e`.
`static IntVector`	`zero(VectorSpecies<Integer> species)`	Возвращает вектор указанного вида со всеми элементами полос, установленными в ноль — значение примитива по умолчанию.

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Integer> SPECIES_64

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

SPECIES_128

public static final VectorSpecies<Integer> SPECIES_128

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

SPECIES_256

public static final VectorSpecies<Integer> SPECIES_256

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

SPECIES_512

public static final VectorSpecies<Integer> SPECIES_512

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

SPECIES_MAX

public static final VectorSpecies<Integer> SPECIES_MAX

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

SPECIES_PREFERRED

public static final VectorSpecies<Integer> SPECIES_PREFERRED

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final IntVector sub(Vector<Integer> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final IntVector sub(int e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final IntVector mul(Vector<Integer> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final IntVector mul(int e)

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

Параметры:

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

Возвращает:

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

См. также:

mul

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

public final IntVector div(Vector<Integer> v)

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

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

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

public final IntVector div(int e)

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

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

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

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

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

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

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


ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

or

public final IntVector or(int e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final IntVector neg()

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

Указано в:

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

Возвращает:

вектор с противоположными знаками элементов

См. также:

abs

public final IntVector abs()

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

Указано в:

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

Возвращает:

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

См. также:

not

public final IntVector not()

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

Возвращает:

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

См. также:

eq

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Integer> eq(int e)

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

Параметры:

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

Возвращает:

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

См. также:

lt

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Integer> lt(int e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare

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

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

См. также:

blend

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

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

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

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

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

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

addIndex

public abstract IntVector addIndex(int scale)

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

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

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

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

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

blend

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

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

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

blend

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

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

slice

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

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

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

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

Параметры:

origin — первый входной элемент, переносимый в срез

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

Возвращает:

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

См. также:

slice

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

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

Указано в:

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

Параметры:

origin — первый входной элемент, переносимый в срез

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

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

Возвращает:

См. также:

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

Возвращает:

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

См. также:

rearrange

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

Возвращает:

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

См. также:

compress

public abstract IntVector compress(VectorMask<Integer> m)

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

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

expand

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

withLane

public abstract IntVector withLane(int i, int e)

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

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

toArray

public final int[] toArray()

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

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

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

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

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


float

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

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

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


float

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

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

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

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

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

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

Возвращает:

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

См. также:

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

species - вид требуемого вектора

a - массив

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

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

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

Возвращает:

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

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

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

См. также:

fromArray

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

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

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

Параметры:

species - вид требуемого вектора

a - массив

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

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

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

Возвращает:

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

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

См. также:

fromMemorySegment

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

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

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

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

Параметры:: species - вид требуемого вектора; ms - сегмент памяти; offset - смещение в сегменте памяти; bo - требуемый порядок байтов
Возвращает:: вектор, загруженный из сегмента памяти
Выбрасывает:: IndexOutOfBoundsException - если offset+N*4 < 0 или offset+N*4 >= ms.byteSize() для любого элемента N вектора; IllegalStateException - если сеанс сегмента памяти не активен или доступ выполняется из потока, отличного от потока-владельца сеанса.
Начиная с:: 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);

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Параметры:

a - массив

offset - смещение, которое нужно объединить со смещениями из карты индексов

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

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

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

См. также:

intoArray

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

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

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

Параметры:

a - массив

offset - смещение, которое нужно объединить со смещениями из карты индексов

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

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

m - маска

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

См. также:

intoMemorySegment

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

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

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

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

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

Определено в:: intoMemorySegment в классе Vector<Integer>
Параметры:: ms - сегмент памяти; offset - смещение в сегменте памяти; bo - требуемый порядок байтов
Начиная с:: 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);
    }
}

Определено в:: intoMemorySegment в классе Vector<Integer>
Параметры:: ms - сегмент памяти; offset - смещение в сегменте памяти; bo - требуемый порядок байтов; m - маска, управляющая выбором элементов
Начиная с:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

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

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

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

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

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

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

Параметры:

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

Возвращает:

признак того, идентичен ли этот вектор другому объекту

См. также:

hashCode

public final int hashCode()

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

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

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Integer> species()

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

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

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

check

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

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Integer> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

conv — требуемое скалярное преобразование, применяемое поэлементно

part — номер части результата или ноль, если преобразование не расширяет и не сужает данные

Возвращает:

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

См. также:

castShape

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

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

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

Указано в:

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

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

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

Параметры:

toSpecies — требуемый выходной вид

part — номер части результата или ноль, если преобразование не расширяет и не сужает данные

Возвращает:

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

См. также:

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://docs.oracle.com/en/java/javase/25/docs/api/jdk.incubator.vector/jdk/incubator/vector/IntVector.html