Класс LongVector

java.lang.Object

jdk.incubator.vector.Vector<Long>

jdk.incubator.vector.LongVector

public abstract class LongVector extends Vector<Long>

LongVector опирается на предварительные функции платформы Java:

LongVector относится к одному или нескольким предварительным API: MemorySegment.

Программы могут использовать LongVector только при включённых предварительных функциях.

Предварительные функции могут быть удалены в будущей версии или обновлены до постоянных функций платформы Java.

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

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

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

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

Модификатор и тип	Метод	Описание
`final LongVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final LongVector`	`add(long e)`	Добавляет этот вектор к результату операции вещания входного скаляра.
`final LongVector`	`add(long e, VectorMask<Long> m)`	Добавляет этот вектор к результату операции вещания входного скаляра, выбирая элементы в соответствии с маской.
`final LongVector`	`add(Vector<Long> v)`	Добавляет этот вектор ко второму входному вектору.
`final LongVector`	`add(Vector<Long> v, VectorMask<Long> m)`	Добавляет этот вектор ко второму входному вектору, выбирая элементы в соответствии с маской.
`abstract LongVector`	`addIndex(int scale)`	Добавляет элементы этого вектора к их соответствующим номерам, умножив на заданную константу.
`final LongVector`	`and(long e)`	Вычисляет побитовое логическое И (`&`) этого вектора и скаляра.
`final LongVector`	`and(Vector<Long> v)`	Вычисляет побитовое логическое И (`&`) этого вектора и второго входного вектора.
`final LongVector`	`bitwiseBlend(long bits, long mask)`	Смешивает биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(long bits, Vector<Long> mask)`	Смешивает биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(Vector<Long> bits, long mask)`	Смешивает биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final LongVector`	`bitwiseBlend(Vector<Long> bits, Vector<Long> mask)`	Смешивает биты двух векторов под управлением третьего, который предоставляет биты маски.
`final LongVector`	`blend(long e, VectorMask<Long> m)`	Заменяет выбранные элементы этого вектора на скалярное значение под управлением маски.
`abstract LongVector`	`blend(Vector<Long> v, VectorMask<Long> m)`	Заменяет выбранные элементы этого вектора соответствующими элементами из второго входного вектора под управлением маски.
`abstract LongVector`	`broadcast(long e)`	Возвращает вектор той же структуры, что и этот, где все элементы заданы примитивным значением `e`.
`static LongVector`	`broadcast(VectorSpecies<Long> species, long e)`	Удобный метод для преобразования вектора из одного типа элементов в другой, изменяя форму при необходимости при изменении размера элементов.
`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)`	Преобразует этот вектор в вектор той же формы и нового типа элементов, преобразуя значения каналов из текущего `ETYPE` в новый тип канала (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`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)`	Делит этот вектор на результат вещания входного скаляра.
`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)`	Загружает вектор из массива типа `long[]`, начиная с заданного смещения.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset)`	Загружает новый вектор, состоящий из элементов массива типа `long[]`, используя индексы, полученные путем добавления фиксированного `offset` к серии дополнительных смещений из карты индексов.
`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[]`, начиная с заданного смещения и используя маску.
`static LongVector`	`fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)`	Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная с заданного смещения в сегменте памяти.
`static LongVector`	`fromMemorySegment(VectorSpecies<Long> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная с заданного смещения в сегменте памяти и используя маску.
`static LongVector`	`fromMemorySegment(VectorSpecies<Long> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo, VectorMask<Long> m)`
`protected final Object`	`getPayload()`	Возвращает код хэширования для вектора.
`final int`	`hashCode()`	Сохраняет этот вектор в массив типа `long[]`, начиная с заданного смещения.
`final void`	`intoArray(long[] a, int offset)`	Размещает этот вектор в массив типа `long[]`, используя индексы, полученные путем добавления фиксированного `offset` к серии дополнительных смещений из карты индексов.
`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[]`, начиная со смещения и используя маску.
`final void`	`intoArray(long[] a, int offset, VectorMask<Long> m)`	Сохраняет этот вектор в сегмент памяти^{ПРЕДПРОСМОТР}, начиная со смещения и используя явную кодировку байтов.
`final void`	`intoMemorySegment(MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти^{ПРЕДПРОСМОТР}, начиная со смещения и используя явную кодировку байтов и маску.

`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> m)`	Перестановка элементов дорожки этого вектора, выбирая дорожки под управлением определенной перестановки.
`abstract LongVector`	`rearrange(VectorShuffle<Long> s, Vector<Long> v)`	Перестановка элементов дорожки двух векторов, выбирая дорожки под управлением определенной перестановки, используя как нормальные, так и исключительные индексы в перестановке для управления данными.
`abstract LongVector`	`rearrange(VectorShuffle<Long> s, VectorMask<Long> m)`	Перестановка элементов дорожки этого вектора, выбирая дорожки под управлением определенной перестановки и маски.
`abstract long`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное со всех дорожек этого вектора.
`abstract long`	`reduceLanes(VectorOperators.Associative op, VectorMask<Long> m)`	Возвращает значение, накопленное с выбранных дорожек этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представление этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `byte`, где байты извлекаются из дорожек в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретация этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `double`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретация этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `float`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретация этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `int`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретация этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `long`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретация этого вектора как вектора с такой же формой и содержимым, но с типом дорожки `short`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract LongVector`	`selectFrom(Vector<Long> v)`	Используя значения индексов, хранящиеся в дорожках этого вектора, собрать значения, хранящиеся во втором векторе `v`.
`abstract LongVector`	`selectFrom(Vector<Long> s, VectorMask<Long> m)`	Используя значения индексов, хранящиеся в дорожках этого вектора, собрать значения, хранящиеся во втором векторе, под управлением маски.
`abstract LongVector`	`slice(int origin)`	Выделение сегмента смежных дорожек, начиная с заданной `origin` дорожки в текущем векторе.
`abstract LongVector`	`slice(int origin, Vector<Long> v1)`	Выделение сегмента смежных дорожек, начиная с заданной `origin` дорожки в текущем векторе и продолжая (при необходимости) в непосредственно следующий вектор.
`final LongVector`	`slice(int origin, Vector<Long> w, VectorMask<Long> m)`	Выделение сегмента смежных дорожек под управлением маски, начиная с заданной `origin` дорожки в текущем векторе и продолжая (при необходимости) в непосредственно следующий вектор.
`final VectorSpecies<Long>`	`species()`	Возвращает вид этого вектора.
`final LongVector`	`sub(long e)`	Вычитание входного скаляра из этого вектора.
`final LongVector`	`sub(long e, VectorMask<Long> m)`	Вычитание входного скаляра из этого вектора под управлением маски.
`final LongVector`	`sub(Vector<Long> v)`	Вычитание второго входного вектора из этого вектора.
`final LongVector`	`sub(Vector<Long> v, VectorMask<Long> m)`	Вычитание второго входного вектора из этого вектора под управлением маски.

`abstract VectorMask<Long>`	`test(VectorOperators.Test op)`	Проверяет дорожки этого вектора в соответствии с заданной операцией.
`abstract VectorMask<Long>`	`test(VectorOperators.Test op, VectorMask<Long> m)`	Проверяет выбранные дорожки этого вектора в соответствии с заданной операцией.
`final long[]`	`toArray()`	Возвращает массив типа `long[]`, содержащий все значения дорожек.
`final double[]`	`toDoubleArray()`	Возвращает массив `double[]` типа, содержащий все значения дорожек, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив `int[]` типа, содержащий все значения дорожек, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает массив `long[]` типа, содержащий все значения дорожек, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора в формате `"[0,1,2...]"`, отображая значения дорожек этого вектора в порядке дорожек.
`abstract LongVector`	`unslice(int origin)`	Инвертирует срез slice(), вставляя текущий вектор в качестве среза в «фоновый» ввод с нулевыми значениями дорожек.
`abstract LongVector`	`unslice(int origin, Vector<Long> w, int part)`	Инвертирует срез slice(), вставляя текущий вектор в качестве среза в другой «фоновый» входной вектор, который рассматривается как один из входов для гипотетической последующей операции `slice()`.
`abstract LongVector`	`unslice(int origin, Vector<Long> w, int part, VectorMask<Long> m)`	Представляет этот вектор как вектор с той же формой, длиной и содержимым, но типом дорожки, являющимся типом с плавающей точкой.
`slice()`	`final DoubleVector`	Представляет этот вектор как вектор с той же формой, длиной и содержимым, но типом дорожки, не являющимся типом с плавающей точкой.
`viewAsFloatingLanes()`	`final LongVector`	Заменяет элемент дорожки этого вектора в индексе дорожки `i` значением `e`.
`viewAsIntegralLanes()`	`abstract LongVector`	Возвращает вектор заданного вида, где все элементы дорожек установлены в ноль, значение по умолчанию для примитива.

Методы, объявленные в классе 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, где все элементы lanes установлены в ноль, значение по умолчанию для примитива.

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

broadcast

public abstract LongVector broadcast(long e)

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

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

Указано в:

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

API Note:

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

Параметры:

e - значение для broadcast

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

e - значение для broadcast

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Unary op)

Работает со значениями lane этого вектора. Это lane-wise унарная операция, которая применяет выбранную операцию к каждому lane.

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

Specified by:

lanewise in class Vector<Long>

Parameters:

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

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

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

Returns:

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

See Also:

lanewise

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

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

Specified by:

lanewise in class Vector<Long>

Parameters:

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

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

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

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

Returns:

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

See Also:

lanewise

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

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

Parameters:

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

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

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

Returns:

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

Throws:

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

See Also:

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

Parameters:

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

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

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

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

Returns:

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

Throws:

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

See Also:

lanewise

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

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

Parameters:

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

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

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

Returns:

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

Throws:

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

See Also:

lanewise

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

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

Parameters:

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

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

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

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

Returns:

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

Throws:

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

See Also:

lanewise

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

Parameters:

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

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

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

Returns:

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

Throws:

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

See Also:

lanewise

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

Parameters:

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

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

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

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

Returns:

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

Throws:

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

See Also:

add

public final LongVector add(Vector<Long> v)

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

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

Specified by:

add in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

add

public final LongVector add(long e)

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

Parameters:

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

Returns:

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

See Also:

add

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

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

Specified by:

add in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

add

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

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

Parameters:

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

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

Returns:

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

See Also:

sub

public final LongVector sub(Vector<Long> v)

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

Specified by:

sub in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

sub

public final LongVector sub(long e)

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

Parameters:

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

Returns:

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

See Also:

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 Note:

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


 ArithmeticException

будет вызвано.

Parameters:

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

Returns:

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

See Also:

div

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

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

Specified by:

div in class Vector<Long>

API Note:

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


 ArithmeticException

будет вызвано.

Parameters:

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

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

Returns:

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

See Also:

div

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

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

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

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


 ArithmeticException

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

Параметры:

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

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

Возвращает:

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

См. также:

min

public final LongVector min(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final LongVector min(long e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(Vector<Long> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(long e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(Vector<Long> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(long e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(Vector<Long> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(long e)

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

Parameters:

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

Returns:

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

See Also:

neg

public final LongVector neg()

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

Specified by:

neg in class Vector<Long>

Returns:

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

See Also:

abs

public final LongVector abs()

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

Specified by:

abs in class Vector<Long>

Returns:

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

See Also:

not

public final LongVector not()

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

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

Returns:

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

See Also:

eq

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

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

Specified by:

eq in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

eq

public final VectorMask<Long> eq(long e)

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

Parameters:

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

Returns:

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

See Also:

lt

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

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

Specified by:

lt in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

lt

public final VectorMask<Long> lt(long e)

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

Parameters:

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

Returns:

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

See Also:

test

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

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

Specified by:

test in class Vector<Long>

Parameters:

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

Returns:

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

See Also:

test

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

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

Specified by:

test in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

Specified by:

compare in class Vector<Long>

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

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

Specified by:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Specified by:

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

Specified by:: 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);

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

blend

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

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

Specified by:: 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.

Это междорожечная операция, которая сдвигает элементы дорожек вперед, из текущего вектора и второго вектора. Оба вектора можно рассматривать как объединенную "фоновую" последовательность длиной 2*VLENGTH, из которой извлекается срез. Возвращаемый результат равен выражению broadcast(0).blend(slice(origin,v1),m).

Specified by:

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 0 или 1 выбирает первый или второй обновлённый фоновый вектор.

Значение 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 0 или 1 выбирает первый или второй обновлённый фоновый вектор.

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract LongVector unslice(int origin)

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


 (origin,

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> m)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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. Все оставшиеся верхние дорожки, если таковые имеются, выходного вектора устанавливаются в ноль.

Specified by:: compress в классе Vector<Long>
Parameters:: m - маска, управляющая сжатием
Returns:: сжатые элементы дорожек этого вектора
Since:: 19

expand

public abstract LongVector expand(VectorMask<Long> m)

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

Specified by:: expand в классе Vector<Long>
Parameters:: m - маска, управляющая сжатием
Returns:: расширенные элементы дорожек этого вектора
Since:: 19

selectFrom

public abstract LongVector selectFrom(Vector<Long> v)

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

selectFrom

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

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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

bitwiseBlend

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

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

Parameters:

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

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

Returns:

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

See Also:

bitwiseBlend

public final LongVector bitwiseBlend(long bits, long mask)

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

Parameters:

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

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

Returns:

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

See Also:

bitwiseBlend

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

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

Parameters:

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

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

Returns:

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

See Also:

bitwiseBlend

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

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

Parameters:

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

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

Returns:

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

See Also:

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Изволяет:

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

См. также:

reduceLanes

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

Изволяет:

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

См. также:

lane

public abstract long lane(int i)

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

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

withLane

public abstract LongVector withLane(int i, long e)

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

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

toArray

public final long[] toArray()

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

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


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

Указано:

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


 float

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

Указано:

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


 float

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

Указано:

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

Указано:

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

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

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

Возвращает:

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

См. также:

fromArray

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

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

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

fromArray

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

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

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, MemorySegmentPREVIEW 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 в векторе; IllegalArgumentException - если сегмент памяти — кучный сегмент, который не поддерживается массивом byte[].; IllegalStateException - если сессия сегмента памяти не активна или доступ осуществляется из потока, отличного от потока, владеющего сессией.
Since:: 19

fromMemorySegment

public static LongVector fromMemorySegment(VectorSpecies<Long> species, MemorySegmentPREVIEW 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 в векторе, где маска установлена; IllegalArgumentException - если сегмент памяти — кучный сегмент, который не поддерживается массивом byte[].; 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:

See Also:

intoMemorySegment

public final void intoMemorySegment(MemorySegmentPREVIEW 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(MemorySegmentPREVIEW 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 in class Vector<Long>

Parameters:

obj - объект-ссылка, с которым нужно сравнить.

Returns:

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

See Also:

hashCode

public final int hashCode()

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

Specified by:

hashCode in class Vector<Long>

Returns:

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

See Also:

species

public final VectorSpecies<Long> species()

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

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

Specified by:: species in class Vector<E>
Returns:: тип этого вектора

check

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

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

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

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

Specified by:

check in class Vector<E>

Type Parameters:

F - тип элемента, требуемый типом

Parameters:

species - требуемый тип

Returns:

тот же вектор

See Also:

check

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

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

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

Specified by:

check in class Vector<E>

Type Parameters:

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

Parameters:

elementType - требуемый тип канала

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Long> maskAll(boolean bit)

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

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

Specified by:

maskAll in class Vector<E>

Parameters:

bit - заданное значение маски для копирования

Returns:

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

See Also:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

Specified by:: reinterpretAsShorts in class Vector<E>
Returns:: a ShortVector с той же формой и информационным содержанием

reinterpretAsInts

public IntVector reinterpretAsInts()

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

Specified by:: reinterpretAsInts in class Vector<E>
Returns:: a IntVector с той же формой и информационным содержанием

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

Specified by:: reinterpretAsLongs in class Vector<E>
Returns:: a LongVector с той же формой и информационным содержанием

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

Specified by:: reinterpretAsFloats in class Vector<E>
Returns:: a FloatVector с той же формой и информационным содержанием

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

Specified by:: reinterpretAsDoubles in class Vector<E>
Returns:: 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);

Specified by:

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

Type Parameters:

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

Parameters:

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

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

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

Returns:

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

See Also:

getPayload

protected final Object getPayload()

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