Класс LongVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

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

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.LongVector

public abstract class LongVector extends Vector<E>

Специализированный 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)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`final VectorMask<Long>`	`compare(VectorOperators.Comparison op, Vector<Long> v, 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)`	Указывает, идентичен ли этот вектор другому объекту.
`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`	`fromByteArray(VectorSpecies<Long> species, byte[] a, int offset, ByteOrder bo)`	Загружает вектор из массива байтов, начиная со смещения.
`static LongVector`	`fromByteArray(VectorSpecies<Long> species, byte[] a, int offset, ByteOrder bo, VectorMask<Long> m)`	Загружает вектор из массива байтов, начиная со смещения и используя маску.
`static LongVector`	`fromByteBuffer(VectorSpecies<Long> species, ByteBuffer bb, int offset, ByteOrder bo)`	Загружает вектор из byte buffer, начиная со смещения в буфере байтов.
`static LongVector`	`fromByteBuffer(VectorSpecies<Long> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Long> m)`	Загружает вектор из byte buffer, начиная со смещения в буфере байтов и используя маску.
`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`	`intoByteArray(byte[] a, int offset, ByteOrder bo)`	Сохраняет этот вектор в массив байтов, начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Long> m)`	Сохраняет этот вектор в массив байтов, начиная со смещения, используя явное порядок байтов и маску.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)`	Сохраняет этот вектор в буфер байтов, начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteBuffer(ByteBuffer bb, int 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)`	Объединяет соответствующие значения полос этого вектора со значениями второго входного вектора.
`final 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)`	Объединяет соответствующие значения полос этого вектора с полосами второго и третьего входных векторов.
`final LongVector`	`lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m)`	Объединяет соответствующие значения полос этого вектора с полосами второго и третьего входных векторов с выбором элементов полос, управляемым маской.
`abstract LongVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операции над значениями полос этого вектора.
`final 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> m)`	Переупорядочивает элементы полос этого вектора, выбирая полосы под управлением определенного перемещения.
`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> 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)`	Проверяет полосы этого вектора в соответствии с заданной операцией.

END_OF_DOCUMENT_MARKER

`final 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()`	Возвращает строковое представление этого вектора в формате `"[0,1,2...]"`, отображающее значения полос этого вектора в порядке полос.
`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)`	Возвращает вектор заданного вида, где все элементы полос установлены в ноль, значение по умолчанию для примитива.

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

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

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

getPayload

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

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

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

SPECIES_64

public static final VectorSpecies<Long> SPECIES_64

Species representing LongVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Long> SPECIES_128

Species representing LongVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Long> SPECIES_256

Species representing LongVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Long> SPECIES_512

Species representing LongVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Long> SPECIES_MAX

Species representing LongVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Long> SPECIES_PREFERRED

Предпочтительный species для LongVectors. Предпочтительный species — это species максимального размера в битах для платформы.

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

zero

public static LongVector zero(VectorSpecies<Long> species)

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

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

broadcast

public abstract LongVector broadcast(long e)

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

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

Указано в:

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

API Note:

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,long,VectorMask)

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

lanewise

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

Параметры:

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

Изволяет:

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

См. также:

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

add

public final LongVector add(Vector<Long> v)

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

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

Specified by:

add in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

add(long)

add

public final LongVector add(long e)

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

Parameters:

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

Returns:

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

See Also:

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

add

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

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

Specified by:

add in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

add(long,VectorMask)

add

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

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

Parameters:

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

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

Returns:

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

See Also:

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

sub

public final LongVector sub(Vector<Long> v)

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

Specified by:

sub in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

sub(long)

sub

public final LongVector sub(long e)

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

Parameters:

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

Returns:

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

See Also:

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

sub

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

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

Specified by:

sub in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

sub(long,VectorMask)

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

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

умн

public final LongVector mul(Vector<Long> v)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

mul(long)

умн

public final LongVector mul(long e)

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

Параметры:

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

Возвращает:

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

См. также:

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

умн

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

mul(long,VectorMask)

умн

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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(Vector)
broadcast(long)
div(long,VectorMask)
VectorOperators.DIV
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,long)

div

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

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

Указано в:

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

div(long,VectorMask)

div

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

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

Возвращает:

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

См. также:

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

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

Возвращает:

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

См. также:

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

and

public final LongVector and(Vector<Long> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

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

and

public final LongVector and(long e)

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

Параметры:

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

Возвращает:

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

См. также:

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

or

public final LongVector or(Vector<Long> v)

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

Параметры:

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

Возвращает:

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

См. также:

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

или

public final LongVector or(long e)

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

Параметры:

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

Возвращает:

бинарную дизъюнкцию (|) этого вектора и скаляра

См. также:

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

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

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

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

Возвращает:

бинарное логическое отрицание (~) этого вектора

См. также:

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

равно

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

равно

public final VectorMask<Long> eq(long e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,long)

меньше

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

меньше

public final VectorMask<Long> lt(long e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,long)

test

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.test(VectorOperators.Test)

compare

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

Vector.compare(VectorOperators.Comparison, Vector)

compare

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

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,Vector,VectorMask)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> s, VectorMask<Long> m)

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

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


 Vector<E> r = this.rearrange(s.wrapIndexes());
 VectorMask<E> valid = s.laneIsValid();
 if (m.andNot(valid).anyTrue()) throw ...;
 return broadcast(0).blend(r, m);

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Переупорядочить

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

Возвращает:

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

См. также:

selectFrom

public abstract LongVector selectFrom(Vector<Long> v)

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

Указано:

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

Параметры:

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

Возвращает:

переупорядоченные элементы проходов v

См. также:

Vector.rearrange(VectorShuffle)

selectFrom

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

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

Указано:

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

Параметры:

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

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

Возвращает:

переупорядоченные элементы проходов v

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

bitwiseBlend

public final LongVector bitwiseBlend(long bits, long mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

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

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

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

reduceLanes

public abstract 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 - если этот вектор не поддерживает запрашиваемую операцию

См. также:

reduceLanes(VectorOperators.Associative)

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

См. также:

fromByteArray

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

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

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


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

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

fromByteArray

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

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

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


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

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

fromArray

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

См. также:

toIntArray()

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

Возвращает:

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

Исключение:

См. также:

toIntArray()

fromByteBuffer

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

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

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


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

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

fromByteBuffer

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

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

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


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

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

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. То есть, сброшенные каналы могут соответствовать индексам массива, меньшим нуля или выходящим за пределы массива.

Parameters:: a - массив типа long[]; offset - смещение в массиве; m - маска, управляющая сохранением каналов
Throws:: 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]].

Parameters:

a - массив

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

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

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

Throws:

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

See Also:

toIntArray()

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

toIntArray()

intoByteArray

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

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

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

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


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

Specified by:: intoByteArray в классе Vector<Long>
Parameters:: a - массив байтов; offset - смещение в массиве; bo - желаемый порядок байтов

intoByteArray

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

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

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


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

Specified by:: intoByteArray в классе Vector<Long>
Parameters:: a - массив байтов; offset - смещение в массиве; bo - желаемый порядок байтов; m - маска, управляющая выбором каналов

intoByteBuffer

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

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

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


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

Specified by:: intoByteBuffer в классе Vector<Long>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - желаемый порядок байтов

intoByteBuffer

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

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

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


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

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


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

Specified by:: intoByteBuffer в классе Vector<Long>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - желаемый порядок байтов; m - маска, управляющая выбором каналов

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом данных, являющимся типом с плавающей точкой. Это переинтерпретация значений данных на уровне отдельных элементов. Таким образом, этот метод не изменяет VSHAPE или VLENGTH, и битовое содержимое вектора не изменяется. Если размер элемента вектора уже является типом с плавающей точкой, возвращается тот же вектор без изменений. Если размер элемента вектора не соответствует размеру ни одного типа с плавающей точкой, выбрасывается 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 - ссылка на объект для сравнения.

Возвращает:

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

См. также:

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

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 - заданное значение маски для копирования

Возвращает:

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

См. также:

VectorSpecies.maskAll(boolean)

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

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

Returns:

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

See Also:

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