Класс IntVector

java.lang.Object

jdk.incubator.vector.Vector<Integer>

jdk.incubator.vector.IntVector

public abstract sealed class IntVector extends Vector<Integer>

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

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

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

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

Модификатор и тип	Метод	Описание
`final IntVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final IntVector`	`add(int e)`	Прибавляет к этому вектору значение скалярного аргумента, распространённое на все элементы.
`final IntVector`	`add(int e, VectorMask<Integer> m)`	Прибавляет к этому вектору значение скалярного аргумента, распространённое на все элементы, выбирая элементы в соответствии с маской.
`final IntVector`	`add(Vector<Integer> v)`	Прибавляет к этому вектору второй входной вектор.
`final IntVector`	`add(Vector<Integer> v, VectorMask<Integer> m)`	Прибавляет к этому вектору второй входной вектор, выбирая элементы в соответствии с маской.
`abstract IntVector`	`addIndex(int scale)`	Прибавляет к элементам этого вектора их соответствующие номера, умноженные на заданную константу.
`final IntVector`	`and(int e)`	Вычисляет побитовое логическое И (`&`) этого вектора и скалярного значения.
`final IntVector`	`and(Vector<Integer> v)`	Вычисляет побитовое логическое И (`&`) этого вектора и второго входного вектора.
`final IntVector`	`bitwiseBlend(int bits, int mask)`	Смешивает биты вектора и скалярного значения под управлением другого скалярного значения, задающего биты маски.
`final IntVector`	`bitwiseBlend(int bits, Vector<Integer> mask)`	Смешивает биты вектора и скалярного значения под управлением другого вектора, задающего биты маски.
`final IntVector`	`bitwiseBlend(Vector<Integer> bits, int mask)`	Смешивает биты двух векторов под управлением скалярного значения, задающего биты маски.
`final IntVector`	`bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)`	Смешивает биты двух векторов под управлением третьего вектора, задающего биты маски.
`final IntVector`	`blend(int e, VectorMask<Integer> m)`	Заменяет выбранные элементы этого вектора скалярным значением в соответствии с маской.
`final IntVector`	`blend(long e, VectorMask<Integer> m)`	Заменяет выбранные элементы этого вектора скалярным значением в соответствии с маской.
`abstract IntVector`	`blend(Vector<Integer> v, VectorMask<Integer> m)`	Заменяет выбранные элементы этого вектора соответствующими элементами второго входного вектора в соответствии с маской.
`abstract IntVector`	`broadcast(int e)`	Возвращает вектор того же вида, что и этот, в котором всем элементам присвоено примитивное значение `e`.
`abstract IntVector`	`broadcast(long e)`	Возвращает вектор того же вида, что и этот, в котором всем элементам присвоено примитивное значение `e`.
`static IntVector`	`broadcast(VectorSpecies<Integer> species, int e)`	Возвращает вектор заданного вида, в котором всем элементам присвоено примитивное значение `e`.
`static IntVector`	`broadcast(VectorSpecies<Integer> species, long e)`	Возвращает вектор заданного вида, в котором всем элементам присвоено примитивное значение `e`.
`final <F> Vector<F>`	`castShape(VectorSpecies<F> toSpecies, int part)`	Вспомогательный метод для преобразования вектора из одного типа элементов в другой с изменением формы при необходимости, если размер элементов меняется.
`final <F> Vector<F>`	`check(Class<F> elementType)`	Проверяет, что этот вектор имеет заданный тип элементов, и возвращает его без изменений.
`final <F> Vector<F>`	`check(VectorSpecies<F> species)`	Проверяет, что этот вектор имеет заданный вид, и возвращает его без изменений.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, int e)`	Проверяет этот вектор, сравнивая его со скалярным аргументом согласно заданной операции сравнения.
`final VectorMask<Integer>`	`compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)`	Проверяет этот вектор, сравнивая его со скалярным аргументом согласно заданной операции сравнения для элементов, выбранных маской.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, long e)`	Проверяет этот вектор, сравнивая его со скалярным аргументом согласно заданной операции сравнения.
`final VectorMask<Integer>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)`	Проверяет этот вектор, сравнивая его со скалярным аргументом согласно заданной операции сравнения для элементов, выбранных маской.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, Vector<Integer> v)`	Проверяет этот вектор, сравнивая его с другим входным вектором согласно заданной операции сравнения.
`abstract IntVector`	`compress(VectorMask<Integer> m)`	Сжимает элементы этого вектора, выбирая их в соответствии с заданной маской.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Integer,F> conv, int part)`	Преобразует этот вектор в вектор той же формы с новым типом элементов, преобразуя значения элементов из текущего `ETYPE` в новый тип элементов (здесь называемый `FTYPE`) согласно указанному преобразованию.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Integer,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного вида, формы и типа элементов, преобразуя значения элементов из текущего `ETYPE` в новый тип элементов (здесь называемый `FTYPE`) согласно указанному преобразованию.
`final IntVector`	`div(int e)`	Делит этот вектор на скалярный аргумент, распространённый на все элементы.
`final IntVector`	`div(int e, VectorMask<Integer> m)`	Делит этот вектор на скалярный аргумент, распространённый на все элементы, выбирая элементы в соответствии с маской.
`final IntVector`	`div(Vector<Integer> v)`	Делит этот вектор на второй входной вектор.
`final IntVector`	`div(Vector<Integer> v, VectorMask<Integer> m)`	Делит этот вектор на второй входной вектор в соответствии с маской.
`final VectorMask<Integer>`	`eq(int e)`	Проверяет, равен ли этот вектор скалярному аргументу.
`final VectorMask<Integer>`	`eq(Vector<Integer> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор другому объекту.
`abstract IntVector`	`expand(VectorMask<Integer> m)`	Расширяет элементы этого вектора в соответствии с заданной маской.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset)`	Загружает вектор из массива типа `int[]`, начиная с заданного смещения.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)`	Собирает новый вектор из элементов массива типа `int[]`, используя индексы, полученные добавлением фиксированного `offset` к ряду дополнительных смещений из карты индексов.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`	Собирает новый вектор из элементов массива типа `int[]` в соответствии с маской, используя индексы, полученные добавлением фиксированного `offset` к ряду дополнительных смещений из карты индексов.
`static IntVector`	`fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)`	Загружает вектор из массива типа `int[]`, начиная с заданного смещения и используя маску.
`static IntVector`	`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная с заданного смещения в сегменте памяти.
`static IntVector`	`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)`	Загружает вектор из сегмента памяти, начиная с заданного смещения в сегменте памяти и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает хеш-код вектора, основанный на значениях элементов и виде вектора.
`final void`	`intoArray(int[] a, int offset)`	Сохраняет этот вектор в массив типа `int[]`, начиная с заданного смещения.
`final void`	`intoArray(int[] a, int offset, int[] indexMap, int mapOffset)`	Раскладывает элементы этого вектора в массив типа `int[]`, используя индексы, полученные добавлением фиксированного `offset` к ряду дополнительных смещений из карты индексов.
`final void`	`intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`	Раскладывает элементы этого вектора в массив типа `int[]` в соответствии с маской, используя индексы, полученные добавлением фиксированного `offset` к ряду дополнительных смещений из карты индексов.
`final void`	`intoArray(int[] a, int offset, VectorMask<Integer> m)`	Сохраняет этот вектор в массив типа `int[]`, начиная с заданного смещения и используя маску.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения и используя явно заданный порядок байтов.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)`	Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения, используя явно заданный порядок байтов и маску.
`abstract int`	`lane(int i)`	Получает элемент вектора с индексом `i`
`final IntVector`	`lanewise(VectorOperators.Binary op, int e)`	Объединяет значения элементов этого вектора со значением скалярного аргумента, распространённым на все элементы.
`final IntVector`	`lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)`	Объединяет значения элементов этого вектора со значением скалярного аргумента, распространённым на все элементы; выбор элементов управляется маской.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения элементов этого вектора со значением скалярного аргумента, распространённым на все элементы.
`final IntVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> m)`	Объединяет соответствующие значения элементов этого вектора со значениями элементов второго входного вектора; выбор элементов управляется маской.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v)`	Объединяет соответствующие значения элементов этого вектора со значениями элементов второго входного вектора.
`abstract IntVector`	`lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> m)`	Объединяет соответствующие значения элементов этого вектора со значениями элементов второго входного вектора; выбор элементов управляется маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2)`	Объединяет значения элементов этого вектора со значениями двух скалярных аргументов, распространённых на все элементы.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)`	Объединяет значения элементов этого вектора со значениями двух скалярных аргументов, распространённых на все элементы; выбор элементов управляется маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)`	Объединяет значения элементов этого вектора со значениями другого вектора и скалярного аргумента, распространённого на все элементы.
`final IntVector`	`lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> m)`	Объединяет значения элементов этого вектора со значениями другого вектора и скалярного аргумента, распространённого на все элементы; выбор элементов управляется маской.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)`	Объединяет значения элементов этого вектора со значениями другого вектора и скалярного аргумента, распространённого на все элементы.
`final IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> m)`	Объединяет значения элементов этого вектора со значениями другого вектора и скалярного аргумента, распространённого на все элементы; выбор элементов управляется маской.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)`	Объединяет соответствующие значения элементов этого вектора с элементами второго и третьего входных векторов.
`abstract IntVector`	`lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> m)`	Объединяет соответствующие значения элементов этого вектора с элементами второго и третьего входных векторов; выбор элементов управляется маской.
`abstract IntVector`	`lanewise(VectorOperators.Unary op)`	Выполняет операцию над значениями элементов этого вектора.
`abstract IntVector`	`lanewise(VectorOperators.Unary op, VectorMask<Integer> m)`	Выполняет операцию над значениями элементов этого вектора; выбор элементов управляется маской.
`final VectorMask<Integer>`	`lt(int e)`	Проверяет, меньше ли этот вектор скалярного аргумента.
`final VectorMask<Integer>`	`lt(Vector<Integer> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Integer>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор; каждый её элемент установлен или сброшен согласно заданному логическому значению, распространяемому на все элементы.
`final IntVector`	`max(int e)`	Вычисляет максимум этого вектора и скалярного аргумента, распространённого на все элементы.
`final IntVector`	`max(Vector<Integer> v)`	Вычисляет максимум этого и второго входного векторов.
`final IntVector`	`min(int e)`	Вычисляет минимум этого вектора и скалярного аргумента, распространённого на все элементы.
`final IntVector`	`min(Vector<Integer> v)`	Вычисляет минимум этого и второго входного векторов.
`final IntVector`	`mul(int e)`	Умножает этот вектор на скалярный аргумент, распространённый на все элементы.
`final IntVector`	`mul(int e, VectorMask<Integer> m)`	Умножает этот вектор на скалярный аргумент, распространённый на все элементы, выбирая элементы в соответствии с маской.
`final IntVector`	`mul(Vector<Integer> v)`	Умножает этот вектор на второй входной вектор.
`final IntVector`	`mul(Vector<Integer> v, VectorMask<Integer> m)`	Умножает этот вектор на второй входной вектор в соответствии с маской.
`final IntVector`	`neg()`	Меняет знак этого вектора.
`final IntVector`	`not()`	Вычисляет побитовое логическое НЕ (`~`) этого вектора.
`final IntVector`	`or(int e)`	Вычисляет побитовое логическое ИЛИ (`\|`) этого вектора и скалярного значения.
`final IntVector`	`or(Vector<Integer> v)`	Вычисляет побитовое логическое ИЛИ (`\|`) этого вектора и второго входного вектора.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> shuffle)`	Переставляет элементы этого вектора, выбирая их в соответствии с заданной операцией перемешивания.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> s, Vector<Integer> v)`	Переставляет элементы двух векторов, выбирая их в соответствии с заданной операцией перемешивания, используя обычные и особые индексы этой операции для направления данных.
`abstract IntVector`	`rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)`	Переставляет элементы этого вектора, выбирая их в соответствии с заданной операцией перемешивания и маской.
`abstract int`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, полученное накоплением значений всех элементов этого вектора.
`abstract int`	`reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)`	Возвращает значение, полученное накоплением значений выбранных элементов этого вектора согласно маске.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и с теми же данными, но с типом элементов `byte`; байты извлекаются из элементов в порядке little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и с теми же данными, но с типом элементов `double`; элементы составляются из последовательных байтов в порядке little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и с теми же данными, но с типом элементов `float`; элементы составляются из последовательных байтов в порядке little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и с теми же данными, но с типом элементов `int`; элементы составляются из последовательных байтов в порядке little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и с теми же данными, но с типом элементов `long`; элементы составляются из последовательных байтов в порядке little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и с теми же данными, но с типом элементов `short`; элементы составляются из последовательных байтов в порядке little-endian.
`abstract IntVector`	`selectFrom(Vector<Integer> v)`	Используя значения индексов в элементах этого вектора, собирает значения из второго вектора `v`.
`abstract IntVector`	`selectFrom(Vector<Integer> v1, Vector<Integer> v2)`	Используя значения в элементах этого вектора, собирает значения из второго вектора `v1` и третьего вектора `v2`.
`abstract IntVector`	`selectFrom(Vector<Integer> s, VectorMask<Integer> m)`	Используя значения индексов в элементах этого вектора, собирает значения из второго вектора в соответствии с маской.
`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)`	Выполняет обратную операцию для slice(), вставляя текущий вектор как срез в «фоновый» вход, состоящий из нулевых значений элементов.
`abstract IntVector`	`unslice(int origin, Vector<Integer> w, int part)`	Выполняет обратную операцию для slice(), вставляя текущий вектор как срез в другой «фоновый» входной вектор, который рассматривается как один из входов гипотетической последующей операции `slice()`.
`abstract IntVector`	`unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> m)`	Выполняет обратную операцию для slice(), вставляя текущий вектор как срез в другой «фоновый» входной вектор в соответствии с маской; этот вектор рассматривается как один из входов гипотетической последующей операции `slice()`.
`final FloatVector`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор той же формы, длины и с теми же данными, но с типом элементов с плавающей точкой.
`final IntVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор той же формы, длины и с теми же данными, но с типом элементов, отличным от типа с плавающей точкой.
`abstract IntVector`	`withLane(int i, int e)`	Заменяет элемент этого вектора с индексом `i` значением `e`.
`static IntVector`	`zero(VectorSpecies<Integer> species)`	Возвращает вектор заданного вида, в котором всем элементам присвоен ноль — значение примитивного типа по умолчанию.

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

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

Модификатор и тип	Метод	Описание
`abstract int`	`bitSize()`	Возвращает общий размер этого вектора в битах.
`abstract int`	`byteSize()`	Возвращает общий размер этого вектора в байтах.
`abstract VectorMask<Integer>`	`compare(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m)`	Проверяет этот вектор, сравнивая его с другим входным вектором согласно заданной операции сравнения для элементов, выбранных маской.
`abstract int`	`elementSize()`	Возвращает размер каждого элемента этого вектора в битах.
`abstract Class<Integer>`	`elementType()`	Возвращает примитивный тип элементов (`ETYPE`) этого вектора.
`abstract int`	`length()`	Возвращает количество элементов, или длину вектора (`VLENGTH`).
`abstract long`	`reduceLanesToLong(VectorOperators.Associative op)`	Возвращает значение, полученное накоплением значений всех элементов этого вектора.
`abstract long`	`reduceLanesToLong(VectorOperators.Associative op, VectorMask<Integer> m)`	Возвращает значение, полученное накоплением значений выбранных элементов этого вектора согласно маске.
`abstract <F> Vector<F>`	`reinterpretShape(VectorSpecies<F> species, int part)`	Преобразует этот вектор в вектор заданного вида с типом элементов `F`, переинтерпретируя байты этого вектора без преобразования значений.
`abstract VectorShape`	`shape()`	Возвращает форму этого вектора.
`abstract VectorShuffle<Integer>`	`toShuffle()`	Преобразует этот вектор в операцию перемешивания, преобразуя значения элементов в `int` и рассматривая их как исходные индексы.

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

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

Модификатор и тип	Метод	Описание
`protected Object`	`clone()`	Создает и возвращает копию этого объекта.
`protected void`	`finalize()`	Устарело, будет удалено: этот элемент API может быть удален в будущей версии. Финализация устарела и будет удалена в одном из будущих выпусков.
`final Class<?>`	`getClass()`	Возвращает класс времени выполнения этого `Object`.
`final void`	`notify()`	Пробуждает один поток, ожидающий на мониторе этого объекта.
`final void`	`notifyAll()`	Пробуждает все потоки, ожидающие на мониторе этого объекта.
`final void`	`wait()`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt.
`final void`	`wait(long timeoutMillis)`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения определенного промежутка реального времени.
`final void`	`wait(long timeoutMillis, int nanos)`	Заставляет текущий поток ожидать пробуждения, обычно в результате вызова notify или interrupt, либо до истечения определенного промежутка реального времени.

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

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)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Объединяет значения элементов этого вектора со значениями другой скалярной величины и другого вектора; выбор элементов управляется маской. Это маскированная поэлементная тернарная операция, применяющая выбранную операцию к каждому элементу. Возвращаемое значение будет равно значению следующего выражения: this.lanewise(op, this.broadcast(e1), v2, 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 — boxed-тип элементов требуемого вида

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

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

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

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

F — boxed-тип элементов требуемого типа элементов

Параметры:

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 результата.

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

Совместное влияние неизменности формы и изменения размера элементов может привести к тому, что входной и выходной виды будут иметь разное количество элементов, вызывая расширение или сжатие и требуя выбора или вставки. Концептуально входные данные поэлементно преобразуются в логический результат, содержащий все преобразованные элементы, что приводит к логическому коэффициенту расширения ML = |FTYPE|/|ETYPE|. Затем результат копируется в выходной вектор, который может точно соответствовать ему (преобразование на месте), быть слишком маленьким (требуется выбор) или слишком большим (требуется вставка).

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

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

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

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

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

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

Неизменность формы может приводить к выбору или вставке

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

Для управления деталями этих расширений и сжатий параметр part выбирает частичные результаты расширений или задает место вставки результатов сжатий в выходной вектор. Для преобразований с неизменной формой (MP=1) возможны следующие случаи:

Поэлементный оператор преобразования на месте (|ETYPE|=|FTYPE|): входные данные, логический результат и выходной вектор имеют одинаковое количество элементов и одинаковый размер в битах (ML=MP=1). Логический результат точно помещается в выходной вектор, поэтому всегда выполняется условие part=0.
Все преобразованные значения помещаются в один выходной вектор, без потери элементов.
Поэлементный расширяющий оператор преобразования (|ETYPE|<|FTYPE|): логическое расширение ML=|FTYPE|/|ETYPE|>1 означает, что логический результат в MS=ML раз больше выходного вектора.
Число part в диапазоне [0..MS-1] выбирает один из MS непересекающихся блоков по VLENGTH/MS элементов логического результата, начинающийся с исходного элемента part*VLENGTH/MS. Выбранный блок копируется в выходной вектор и полностью заполняет его. Остальная часть логического результата теряется.

Группа таких выходных векторов с MS непересекающимися выборками логических результатов может (вручную) представлять полный логический результат преобразования.
Поэлементный сжимающий оператор преобразования (|ETYPE|>|FTYPE|): логическое сжатие ML=|FTYPE|/|ETYPE|<1 означает, что выходной вектор в MO=1/ML раз больше логического результата.
Число part в диапазоне [-(MO-1)..0] вставляет все VLENGTH элементов логического результата в выходной вектор, начиная с исходного элемента -part*VLENGTH. Всего имеется VLENGTH*MO выходных элементов; не содержащие преобразованных входных значений элементы заполняются нулями.

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

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

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

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

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

F — boxed-тип элементов данного вида

Параметры:

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 — boxed-тип элементов выходного вида

Параметры:

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(), чтобы код было легче анализировать. В противном случае это операция изменения формы, которая может иметь особые затраты на реализацию.

Совместное влияние изменения формы и размера элементов может привести к тому, что входной и выходной виды будут иметь разное количество элементов, вызывая расширение или сжатие и требуя выбора или вставки. Концептуально входные данные поэлементно преобразуются в логический результат, содержащий все преобразованные элементы, что приводит к логическому коэффициенту расширения ML = |FTYPE|/|ETYPE|. Затем результат копируется в выходной вектор, который может точно соответствовать ему (преобразование на месте), быть слишком маленьким (требуется выбор) или слишком большим (требуется вставка).

Точное соответствие (преобразование на месте): расширение или сжатие физической формы совпадает с расширением или сжатием элементов (MP=ML). Должно выполняться условие part=0.
Логический результат в MS>1 раз больше выходной формы (выбор): число part в диапазоне [0..MS-1] определяет, какая из MS различных частей логического результата выбирается для выходного вектора. Остальная часть логического результата теряется.
Выходная форма в MO>1 раз больше логического результата (вставка): число part в диапазоне [-(MO-1)..0] определяет, в какую из MO различных позиций выходного вектора вставляется логический результат. Остальная часть выходного вектора заполняется нулевыми битами.

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

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) { // MS=MO=1 => in-place
    assert part == 0; //else AIOOBE
    physical = logical;
} else if (domlen > ranlen) { // MS>1 => selection
    int MS = domlen / ranlen;
    assert 0 <= part && part < MS; //else AIOOBE
    int origin = part * ranlen;
    physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
} else { // (domlen < ranlen) // MO>1 => insertion, padding
    int MO = ranlen / domlen;
    assert 0 >= part && part > -MO; //else AIOOBE
    int origin = -part * domlen;
    System.arraycopy(logical, 0, physical, origin, domlen);
}
return FVector.fromArray(ran, physical, 0);

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

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

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

F — boxed-тип элементов выходного вида

Параметры:

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.