Класс LongVector

java.lang.Object

jdk.incubator.vector.Vector<Long>

jdk.incubator.vector.LongVector

public abstract class LongVector extends Vector<Long>

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

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

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

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

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

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Long> SPECIES_64

Типоразмер, представляющий LongVector с VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Long> SPECIES_128

Типоразмер, представляющий LongVector с VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Long> SPECIES_256

Типоразмер, представляющий LongVector с VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Long> SPECIES_512

Типоразмер, представляющий LongVector с VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Long> SPECIES_MAX

Типоразмер, представляющий LongVector с VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Long> SPECIES_PREFERRED

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

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

zero

public static LongVector zero(VectorSpecies<Long> species)

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

Параметры:: species — типоразмер требуемого нулевого вектора
Возвращает:: нулевой вектор

broadcast

public abstract LongVector broadcast(long e)

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

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

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

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

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

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

Параметры:

e — значение для broadcast-операции

Возвращает:

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

См. также:

broadcast

public static LongVector broadcast(VectorSpecies<Long> species, long e)

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

Параметры:

species — типоразмер требуемого вектора

e — значение для broadcast-операции

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Unary op)

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

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

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

Параметры:

op — операция для обработки элементов

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Unary op, VectorMask<Long> m)

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

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

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

Параметры:

op — операция для обработки элементов

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

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Binary op, Vector<Long> v)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

op — операция для обработки элементов

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

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

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

Параметры:

op — операция для обработки элементов

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

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

Возвращает:

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

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

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2)

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, long e1, long e2)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, long e1, long e2, VectorMask<Long> m)

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2, VectorMask<Long> m)

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2)

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final LongVector lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2, VectorMask<Long> m)

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

add

public final LongVector add(Vector<Long> v)

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

Этот именованный метод полного набора доступен в перегруженных вариантах с маской и без неё, а также (в подклассах) в вариантах с broadcast-скаляром (с маской и без неё).

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

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

Параметры:

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

Возвращает:

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

См. также:

add

public final LongVector add(long e)

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

Параметры:

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

Возвращает:

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

См. также:

add

public final LongVector add(Vector<Long> v, VectorMask<Long> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

add

public final LongVector add(long e, VectorMask<Long> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final LongVector sub(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final LongVector sub(long e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final LongVector sub(Vector<Long> v, VectorMask<Long> m)

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final LongVector sub(long e, VectorMask<Long> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final LongVector mul(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final LongVector mul(long e)

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final LongVector mul(Vector<Long> v, VectorMask<Long> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final LongVector mul(long e, VectorMask<Long> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

div

public final LongVector div(Vector<Long> v)

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

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

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

public final LongVector div(long e)

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

public final LongVector div(Vector<Long> v, VectorMask<Long> m)

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

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

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

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

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


ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div

public final LongVector div(long e, VectorMask<Long> m)

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

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

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


ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

min

public final LongVector min(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final LongVector min(long e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(Vector<Long> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(long e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(Vector<Long> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(long e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(Vector<Long> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(long e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final LongVector neg()

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

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

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

Возвращает:

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

См. также:

abs

public final LongVector abs()

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

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

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

Возвращает:

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

См. также:

not

public final LongVector not()

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

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

Возвращает:

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

См. также:

eq

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

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

Переопределяет:

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Long> eq(long e)

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

Параметры:

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

Возвращает:

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

См. также:

lt

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

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

Переопределяет:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Long> lt(long e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Переопределяет:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Переопределяет:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Переопределяет:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

Переопределяет:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Переопределяет:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

blend

public abstract LongVector blend(Vector<Long> v, VectorMask<Long> 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<Long>
Параметры:: v — второй входной вектор, содержащий значения элементов для замены; m — маска, определяющая выбор элементов из второго входного вектора
Возвращает:: результат объединения элементов этого вектора с элементами второго входного вектора

addIndex

public abstract LongVector 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<Long>
Параметры:: scale — число, на которое умножается индекс каждого элемента N, обычно 1
Возвращает:: результат увеличения значения каждого элемента на соответствующий индекс N, умноженный на scale

blend

public final LongVector blend(long e, VectorMask<Long> m)

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

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

slice

public abstract LongVector slice(int origin, Vector<Long> 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 LongVector slice(int origin, Vector<Long> w, VectorMask<Long> m)

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

Переопределяет:

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

Параметры:

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

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

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

Возвращает:

См. также:

slice

public abstract LongVector slice(int origin)

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


(origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

Параметры:

origin — первый выходной элемент, в который помещается фрагмент

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

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

Возвращает:

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

См. также:

unslice

public abstract LongVector unslice(int origin, Vector<Long> w, int part, VectorMask<Long> m)

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

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

Переопределяет:

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

Параметры:

origin — первый выходной элемент, в который помещается фрагмент

w — фоновый вектор, который (в виде двух копий) получит вставленный фрагмент, если элементы выбраны в m

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

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

Возвращает:

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

См. также:

unslice

public abstract LongVector unslice(int origin)

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


(origin,

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

Переопределяет:

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

Параметры:

origin — первый выходной элемент, в который помещается фрагмент

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> shuffle)

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

Переопределяет:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

Параметры:

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

m — маска, определяющая применение перестановки

Возвращает:

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

См. также:

rearrange

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

Параметры:

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

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

Возвращает:

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

См. также:

compress

public abstract LongVector compress(VectorMask<Long> m)

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

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

expand

public abstract LongVector expand(VectorMask<Long> m)

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

Указано в:: expand в классе Vector<Long>
Параметры:: m — маска, управляющая сжатием
Возвращает:: расширенные элементы этого вектора
Начиная с:: 19

selectFrom

public abstract LongVector selectFrom(Vector<Long> v)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

public abstract LongVector selectFrom(Vector<Long> s, VectorMask<Long> m)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

selectFrom

public abstract LongVector selectFrom(Vector<Long> v1, Vector<Long> 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<Long>

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(Vector<Long> bits, Vector<Long> mask)

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

Параметры:

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

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(long bits, long mask)

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

Параметры:

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

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(long bits, Vector<Long> mask)

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

Параметры:

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

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(Vector<Long> bits, long mask)

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

Параметры:

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

mask — побитовая маска, разрешающая смешивание входных битов

Возвращает:

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

См. также:

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

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

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

См. также:

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op, VectorMask<Long> m)

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

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

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

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lane

public abstract long lane(int i)

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

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

withLane

public abstract LongVector withLane(int i, long e)

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

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

toArray

public final long[] toArray()

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

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

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

Указано в:

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


float

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

Указано в:

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


float

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

Указано в:

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

Указано в:

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

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

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

Возвращает:

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

См. также:

fromArray

public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset)

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

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

fromArray

public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)

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

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

fromArray

public static LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset)

Собирает новый вектор из элементов массива типа long[], используя индексы, полученные прибавлением фиксированного значения 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 LongVector fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)

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

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

Параметры:

species — тип желаемого вектора

a — массив

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

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

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

Возвращает:

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

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

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

См. также:

fromMemorySegment

public static LongVector fromMemorySegment(VectorSpecies<Long> 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*8 < 0 или offset+N*8 >= ms.byteSize() для любой полосы N вектора; IllegalStateException — если сеанс сегмента памяти неактивен или доступ осуществляется из потока, отличного от потока, которому принадлежит сеанс.
С версии:: 19

fromMemorySegment

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

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

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

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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Параметры:

a — массив

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

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

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

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

См. также:

intoArray

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

Распределяет этот вектор по массиву типа long[] под управлением маски, используя индексы, полученные путём прибавления фиксированного 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<Long>
Параметры:: ms — сегмент памяти; offset — смещение в сегменте памяти; bo — требуемый порядок байтов
С версии:: 19

intoMemorySegment

public final void intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> 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<Long>
Параметры:: ms — сегмент памяти; offset — смещение в сегменте памяти; bo — требуемый порядок байтов; m — маска, управляющая выбором полос
С версии:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

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

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

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

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

public final int hashCode()

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

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

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Long> species()

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

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

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

check

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

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

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

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

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

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

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

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

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

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

Параметры:

elementType — требуемый тип полосы

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Long> maskAll(boolean bit)

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

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

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

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

Параметры:

bit — заданный бит маски для копирования

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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