Класс LongVector

java.lang.Object

jdk.incubator.vector.Vector<Long>

jdk.incubator.vector.LongVector

public abstract class LongVector extends Vector<Long>

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

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

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

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

Modifier and Type	Method	Описание
`final LongVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final LongVector`	`add(long e)`	Добавляет этот вектор к широковещательной передаче входного скаляра.
`final LongVector`	`add(long e, VectorMask<Long> m)`	Добавляет этот вектор к широковещательной передаче входного скаляра, выбирая элементы дорожки, управляемые маской.
`final LongVector`	`add(Vector<Long> v)`	Добавляет этот вектор к второму входному вектору.
`final LongVector`	`add(Vector<Long> v, VectorMask<Long> m)`	Добавляет этот вектор ко второму входному вектору, выбирая дорожки под управлением маски.
`abstract LongVector`	`addIndex(int scale)`	Добавляет дорожки этого вектора к соответствующим номерам дорожек, масштабируя их заданной константой.
`final LongVector`	`and(long e)`	Вычисляет побитовое логическое соединение (`&`) этого вектора и скаляра.
`final LongVector`	`and(Vector<Long> v)`	Вычисляет побитовое логическое соединение (`&`) этого вектора и второго входного вектора.
`final LongVector`	`bitwiseBlend(long bits, long mask)`	Комбинирует биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(long bits, Vector<Long> mask)`	Комбинирует биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(Vector<Long> bits, long mask)`	Комбинирует биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(Vector<Long> bits, Vector<Long> mask)`	Комбинирует биты двух векторов под управлением третьего, который предоставляет биты маски.
`final LongVector`	`blend(long e, VectorMask<Long> m)`	Заменяет выбранные дорожки этого вектора скалярным значением под управлением маски.
`abstract LongVector`	`blend(Vector<Long> v, VectorMask<Long> m)`	Заменяет выбранные дорожки этого вектора соответствующими дорожками из второго входного вектора под управлением маски.
`abstract LongVector`	`broadcast(long e)`	Возвращает вектор того же типа, что и этот, где все элементы дорожки установлены в примитивное значение `e`.
`static LongVector`	`broadcast(VectorSpecies<Long> species, long e)`	Возвращает вектор заданного типа, где все элементы дорожки установлены в примитивное значение `e`.
`final <F> Vector<F>`	`castShape(VectorSpecies<F> toSpecies, int part)`	Метод-утилита для преобразования вектора из одного типа дорожки в другой, с необходимым изменением формы при изменении размера дорожек.
`final <F> Vector<F>`	`check(Class<F> elementType)`	Проверяет, что у этого вектора есть указанный тип элемента, и возвращает этот вектор без изменений.
`final <F> Vector<F>`	`check(VectorSpecies<F> species)`	Проверяет, что у этого вектора есть указанный тип, и возвращает этот вектор без изменений.
`abstract VectorMask<Long>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Long>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Long> m)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения на дорожках, выбранных маской.
`abstract VectorMask<Long>`	`compare(VectorOperators.Comparison op, Vector<Long> v)`	Тестирует этот вектор, сравнивая его с другим входным вектором в соответствии с заданной операцией сравнения.
`abstract LongVector`	`compress(VectorMask<Long> m)`	Сжимает элементы дорожек этого вектора, выбирая дорожки под управлением определенной маски.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Long,F> conv, int part)`	Преобразует этот вектор в вектор той же формы и нового типа элемента, преобразуя значения дорожек из текущего `ETYPE` в новый тип дорожки (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Long,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного типа, формы и типа элемента, преобразуя значения дорожек из текущего `ETYPE` в новый тип дорожки (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`final LongVector`	`div(long e)`	Делит этот вектор на широковещательную передачу входного скаляра.
`final LongVector`	`div(long e, VectorMask<Long> m)`	Делит этот вектор на широковещательную передачу входного скаляра, выбирая элементы дорожки, управляемые маской.
`final LongVector`	`div(Vector<Long> v)`	Делит этот вектор на второй входной вектор.
`final LongVector`	`div(Vector<Long> v, VectorMask<Long> m)`	Делит этот вектор на второй входной вектор под управлением маски.
`final VectorMask<Long>`	`eq(long e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Long>`	`eq(Vector<Long> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`abstract LongVector`	`expand(VectorMask<Long> m)`	Расширяет элементы дорожек этого вектора под управлением определенной маски.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset)`	Загружает вектор из массива типа `long[]`, начиная с смещения.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, составленный из элементов массива типа `long[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)`	Собрать новый вектор, составленный из элементов массива типа `long[]`, под управлением маски и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)`	Загружает вектор из массива типа `long[]`, начиная со смещения и используя маску.
`static LongVector`	`fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная со смещения в сегмент памяти.
`static LongVector`	`fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)`	Загружает вектор из сегмента памяти, начиная со смещения в сегмент памяти и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает хэш-код вектора.
`final void`	`intoArray(long[] a, int offset)`	Сохраняет этот вектор в массив типа `long[]`, начиная со смещения.
`final void`	`intoArray(long[] a, int offset, int[] indexMap, int mapOffset)`	Разбрасывает этот вектор в массив типа `long[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)`	Разбрасывает этот вектор в массив типа `long[]`, под управлением маски и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(long[] a, int offset, VectorMask<Long> m)`	Сохраняет этот вектор в массив типа `long[]`, начиная со смещения и используя маску.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная со смещения с явным порядком байтов.
`final void`	`intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)`	Сохраняет этот вектор в сегмент памяти, начиная со смещения с явным порядком байтов и маской.
`abstract long`	`lane(int i)`	Получает элемент дорожки с индексом дорожки `i`
`final LongVector`	`lanewise(VectorOperators.Binary op, long e)`	Комбинирует значения дорожек этого вектора со значением широковещательного скаляра.

`final LongVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Long> m)`	Объединяет значения проходов этого вектора со значением широковещательного скаляра, с выбором элементов проходов, управляемым маской.
`abstract LongVector`	`lanewise(VectorOperators.Binary op, Vector<Long> v)`	Объединяет соответствующие значения проходов этого вектора со значениями второго входного вектора.
`abstract LongVector`	`lanewise(VectorOperators.Binary op, Vector<Long> v, VectorMask<Long> m)`	Объединяет соответствующие значения проходов этого вектора со значениями второго входного вектора, с выбором элементов проходов, управляемым маской.
`final LongVector`	`lanewise(VectorOperators.Ternary op, long e1, long e2)`	Объединяет значения проходов этого вектора со значениями двух широковещательных скаляров.
`final LongVector`	`lanewise(VectorOperators.Ternary op, long e1, long e2, VectorMask<Long> m)`	Объединяет значения проходов этого вектора со значениями двух широковещательных скаляров, с выбором элементов проходов, управляемым маской.
`final LongVector`	`lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2)`	Объединяет значения проходов этого вектора со значениями другого вектора и широковещательного скаляра.
`final LongVector`	`lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2, VectorMask<Long> m)`	Объединяет значения проходов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов проходов, управляемым маской.
`final LongVector`	`lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2)`	Объединяет значения проходов этого вектора со значениями другого вектора и широковещательного скаляра.
`final LongVector`	`lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2, VectorMask<Long> m)`	Объединяет значения проходов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов проходов, управляемым маской.
`abstract LongVector`	`lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2)`	Объединяет соответствующие значения проходов этого вектора с проходами второго и третьего входных векторов.
`abstract LongVector`	`lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> m)`	Объединяет соответствующие значения проходов этого вектора с проходами второго и третьего входных векторов, с выбором элементов проходов, управляемым маской.
`abstract LongVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операцию над значениями проходов этого вектора.
`abstract LongVector`	`lanewise(VectorOperators.Unary op, VectorMask<Long> m)`	Осуществляет операцию над значениями проходов этого вектора, с выбором элементов проходов, управляемым маской.
`final VectorMask<Long>`	`lt(long e)`	Проверяет, является ли этот вектор меньше входного скаляра.
`final VectorMask<Long>`	`lt(Vector<Long> v)`	Проверяет, является ли этот вектор меньше другого входного вектора.
`final VectorMask<Long>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор, где каждый проход устанавливается или сбрасывается в соответствии с заданным одиночным булевым значением, которое транслируется во все проходы.
`final LongVector`	`max(long e)`	Вычисляет большее из этого вектора и широковещательного входного скаляра.
`final LongVector`	`max(Vector<Long> v)`	Вычисляет большее из этого вектора и второго входного вектора.
`final LongVector`	`min(long e)`	Вычисляет меньшее из этого вектора и широковещательного входного скаляра.
`final LongVector`	`min(Vector<Long> v)`	Вычисляет меньшее из этого вектора и второго входного вектора.
`final LongVector`	`mul(long e)`	Умножает этот вектор на широковещательный входной скаляр.
`final LongVector`	`mul(long e, VectorMask<Long> m)`	Умножает этот вектор на широковещательный входной скаляр, выбирая элементы проходов, управляемые маской.
`final LongVector`	`mul(Vector<Long> v)`	Умножает этот вектор на второй входной вектор.
`final LongVector`	`mul(Vector<Long> v, VectorMask<Long> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final LongVector`	`neg()`	Инвертирует этот вектор.
`final LongVector`	`not()`	Вычисляет поразрядное логическое отрицание (`~`) этого вектора.
`final LongVector`	`or(long e)`	Вычисляет поразрядное логическое дизъюнкцию (`\|`) этого вектора и скаляра.
`final LongVector`	`or(Vector<Long> v)`	Вычисляет поразрядное логическое дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract LongVector`	`rearrange(VectorShuffle<Long> shuffle)`	Переупорядочивает элементы проходов этого вектора, выбирая проходы под управлением определенной перестановки.
`abstract LongVector`	`rearrange(VectorShuffle<Long> s, Vector<Long> v)`	Переупорядочивает элементы проходов двух векторов, выбирая проходы под управлением определенной перестановки, используя как нормальные, так и исключительные индексы в перестановке для управления данными.
`abstract LongVector`	`rearrange(VectorShuffle<Long> s, VectorMask<Long> m)`	Переупорядочивает элементы проходов этого вектора, выбирая проходы под управлением определенной перестановки и маски.
`abstract long`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное со всех проходов этого вектора.
`abstract long`	`reduceLanes(VectorOperators.Associative op, VectorMask<Long> m)`	Возвращает значение, накопленное из выбранных проходов этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и содержимого, но типа проходов `byte`, где байты извлекаются из проходов в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа проходов `double`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа проходов `float`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа проходов `int`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа проходов `long`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переосмысливает этот вектор как вектор той же формы и содержимого, но типа проходов `short`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract LongVector`	`selectFrom(Vector<Long> v)`	Используя значения индексов, хранящиеся в проходах этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`abstract LongVector`	`selectFrom(Vector<Long> v1, Vector<Long> v2)`	Используя значения, хранящиеся в проходах этого вектора, собирает значения, хранящиеся во втором векторе `v1` и третьем векторе `v2`.
`abstract LongVector`	`selectFrom(Vector<Long> s, VectorMask<Long> m)`	Используя значения индексов, хранящиеся в проходах этого вектора, собирает значения, хранящиеся во втором векторе, под управлением маски.
`abstract LongVector`	`slice(int origin)`	Вырезает сегмент смежных проходов, начиная с заданного `origin` прохода в текущем векторе.
`abstract LongVector`	`slice(int origin, Vector<Long> v1)`	Вырезает сегмент смежных проходов, начиная с заданного `origin` прохода в текущем векторе и продолжая (при необходимости) в непосредственно последующий вектор.
`final LongVector`	`slice(int origin, Vector<Long> w, VectorMask<Long> m)`	Вырезает сегмент смежных проходов под управлением маски, начиная с заданного `origin` прохода в текущем векторе и продолжая (при необходимости) в непосредственно последующий вектор.
`final VectorSpecies<Long>`	`species()`	Возвращает вид этого вектора.
`final LongVector`	`sub(long e)`	Вычитает входной скаляр из этого вектора.
`final LongVector`	`sub(long e, VectorMask<Long> m)`	Вычитает входной скаляр из этого вектора под управлением маски.
`final LongVector`	`sub(Vector<Long> v)`	Вычитает второй входной вектор из этого вектора.
`final LongVector`	`sub(Vector<Long> v, VectorMask<Long> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Long>`	`test(VectorOperators.Test op)`	Проверяет проходы этого вектора в соответствии с заданной операцией.

`abstract VectorMask<Long>`	`test(VectorOperators.Test op, VectorMask<Long> m)`	Тестирует выбранные полосы этого вектора в соответствии с заданной операцией.
`final long[]`	`toArray()`	Возвращает массив типа `long[]`, содержащий все значения полос.
`final double[]`	`toDoubleArray()`	Возвращает массив типа `double[]`, содержащий все значения полос, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив типа `int[]`, содержащий все значения полос, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает строковое представление этого вектора в формате `"[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, compare, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle

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

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

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

SPECIES_64

public static final VectorSpecies<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 abstract LongVector lanewise(VectorOperators.Unary op, VectorMask<Long> m)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

add

public final LongVector add(Vector<Long> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

add

public final LongVector add(long e)

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

Параметры:

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

Возвращает:

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

См. также:

add

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

add

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final LongVector sub(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final LongVector sub(long e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

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

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

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

Specified by:

sub in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final LongVector mul(Vector<Long> v)

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

Specified by:

mul in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

mul

public final LongVector mul(long e)

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

Parameters:

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

Returns:

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

See Also:

mul

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

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

Specified by:

mul in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

mul

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

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

Parameters:

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

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

Returns:

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

See Also:

div

public final LongVector div(Vector<Long> v)

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

Specified by:

div in class Vector<Long>

API Note:

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


 ArithmeticException

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

Parameters:

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

Returns:

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

See Also:

div

public final LongVector div(long e)

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

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

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


 ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

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

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

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

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

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

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

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


 ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

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


 ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

min

public final LongVector min(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final LongVector min(long e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(Vector<Long> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(long e)

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

Параметры:

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

Возвращает:

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

См. также:

и

public final LongVector and(Vector<Long> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

и

public final LongVector and(long e)

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

Параметры:

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

Возвращает:

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

См. также:

или

public final LongVector or(Vector<Long> v)

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

Параметры:

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

Возвращает:

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

См. также:

или

public final LongVector or(long e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final LongVector neg()

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

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

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

Возвращает:

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

См. также:

abs

public final LongVector abs()

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

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

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

Возвращает:

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

См. также:

не

public final LongVector not()

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

Возвращает:

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

См. также:

равно

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

См. также:

lt

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Long> lt(long e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

blend

public abstract LongVector blend(Vector<Long> v, VectorMask<Long> m)

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

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

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


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

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

addIndex

public abstract LongVector addIndex(int scale)

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

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

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


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

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

blend

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

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

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

slice

public abstract LongVector slice(int origin, Vector<Long> v1)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

slice

public final LongVector slice(int origin, Vector<Long> w, VectorMask<Long> m)

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

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

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

Параметры:

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

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

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

Возвращает:

См. также:

slice

public abstract LongVector slice(int origin)

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


 (origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

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

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract LongVector unslice(int origin)

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


 (origin,

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

Указано в:

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

Параметры:

origin - первый выходной канал, который примет слайс

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> shuffle)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> s, Vector<Long> v)

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

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


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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compress

public abstract LongVector compress(VectorMask<Long> m)

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

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

expand

public abstract LongVector expand(VectorMask<Long> m)

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

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

selectFrom

public abstract LongVector selectFrom(Vector<Long> v)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

selectFrom

public abstract LongVector selectFrom(Vector<Long> v1, Vector<Long> v2)

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

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

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

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

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

Параметры:

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

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

Возвращает:

перестановка ячеичных элементов v1 и v2

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(long bits, long mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes

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

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

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

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

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

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

Parameters:

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

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

Returns:

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

Throws:

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

See Also:

lane

public abstract long lane(int i)

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

Parameters:: i - индекс элемента
Returns:: элемент по индексу i
Throws:: IllegalArgumentException - если индекс вне диапазона (< 0 || >= length())

withLane

public abstract LongVector withLane(int i, long e)

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

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

toArray

public final long[] toArray()

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

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


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

Specified by:

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

Returns:

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

See Also:

toIntArray

public final int[] toIntArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toLongArray

public final long[] toLongArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toDoubleArray

public final double[] toDoubleArray()

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

fromArray

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

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

Parameters:: species - вид требуемого вектора; a - массив; offset - смещение в массиве
Returns:: вектор, загруженный из массива
Throws:: 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.

Parameters:: species - вид требуемого вектора; a - массив; offset - смещение в массиве; m - маска, управляющая выбором элементов
Returns:: вектор, загруженный из массива
Throws:: 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]].

Parameters:

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

a — массив

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

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

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

Returns:

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

Throws:

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

See Also:

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]]. Выключенные элементы в результирующем векторе устанавливаются в ноль.

Parameters:

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

a — массив

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

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

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

Returns:

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

Throws:

See Also:

fromMemorySegment

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

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

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


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

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

fromMemorySegment

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

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

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


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

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

intoArray

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

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

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

Parameters:: a — массив типа long[]; offset — смещение в массиве
Throws:: 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:

See Also:

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:

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

See Also:

intoMemorySegment

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

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

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

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


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

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

intoMemorySegment

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

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

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

reinterpretAsBytes в классе Vector<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, если такой есть.

Specified by:

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

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

значение хэш-кода для этого вектора

See Also:

species

public final VectorSpecies<Long> species()

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

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

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

END_OF_DOCUMENT_MARKER

Проверка

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

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

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

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

Указано:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

Проверка

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)

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

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

Указано:

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

castShape

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

convertShape

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

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

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

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

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


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

Указано:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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