Класс LongVector

java.lang.Object

jdk.incubator.vector.Vector<Long>

jdk.incubator.vector.LongVector

public abstract sealed class LongVector extends Vector<Long>

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

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

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

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

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

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

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

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Long> SPECIES_64

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

SPECIES_128

public static final VectorSpecies<Long> SPECIES_128

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

SPECIES_256

public static final VectorSpecies<Long> SPECIES_256

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

SPECIES_512

public static final VectorSpecies<Long> SPECIES_512

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

SPECIES_MAX

public static final VectorSpecies<Long> SPECIES_MAX

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

SPECIES_PREFERRED

public static final VectorSpecies<Long> SPECIES_PREFERRED

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

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

zero

public static LongVector zero(VectorSpecies<Long> species)

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

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

broadcast

public abstract LongVector broadcast(long e)

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

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

Задано в:

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

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

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

Параметры:

e — значение для трансляции

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

e — значение для трансляции

Возвращает:

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

См. также:

lanewise

public abstract LongVector lanewise(VectorOperators.Unary op)

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Задано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

add

public final LongVector add(Vector<Long> v)

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

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

add

public final LongVector add(long e)

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

Параметры:

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

Возвращает:

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

См. также:

add

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

add

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final LongVector sub(Vector<Long> v)

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final LongVector sub(long e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

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

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final LongVector mul(Vector<Long> v)

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final LongVector mul(long e)

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

Параметры:

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

Возвращает:

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

См. также:

mul

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

public final LongVector div(Vector<Long> v)

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

Определён в:

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

public final LongVector div(long e)

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

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

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


ArithmeticException

Параметры:

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

Возвращает:

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

См. также:

div

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

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

Определён в:

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

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

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


ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

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


ArithmeticException

Параметры:

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

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

Возвращает:

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

См. также:

min

public final LongVector min(Vector<Long> v)

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

min

public final LongVector min(long e)

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(Vector<Long> v)

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

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

max

public final LongVector max(long e)

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(Vector<Long> v)

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

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

Параметры:

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

Возвращает:

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

См. также:

and

public final LongVector and(long e)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(Vector<Long> v)

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

Параметры:

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

Возвращает:

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

См. также:

or

public final LongVector or(long e)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final LongVector neg()

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

Определён в:

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

Возвращает:

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

См. также:

abs

public final LongVector abs()

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

Определён в:

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

Возвращает:

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

См. также:

not

public final LongVector not()

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

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

Возвращает:

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

См. также:

eq

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

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Long> eq(long e)

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

Параметры:

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

Возвращает:

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

См. также:

lt

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

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Long> lt(long e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

blend

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

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

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

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

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

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

addIndex

public abstract LongVector addIndex(int scale)

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

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

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

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

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

blend

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

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

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

slice

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

slice

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

См. также:

slice

public abstract LongVector slice(int origin)

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


(origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

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

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

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

Задано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

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

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

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

Задано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract LongVector unslice(int origin)

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


(origin,

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract LongVector rearrange(VectorShuffle<Long> shuffle)

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

Задано в:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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

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

Задано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

rearrange

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compress

public abstract LongVector compress(VectorMask<Long> m)

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

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

expand

public abstract LongVector expand(VectorMask<Long> m)

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

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

selectFrom

public abstract LongVector selectFrom(Vector<Long> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

selectFrom

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

public final LongVector bitwiseBlend(long bits, long mask)

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

bitwiseBlend

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

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

Параметры:

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

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

Возвращает:

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

См. также:

reduceLanes

public abstract long reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lane

public abstract long lane(int i)

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

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

withLane

public abstract LongVector withLane(int i, long e)

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

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

toArray

public final long[] toArray()

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

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

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

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

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


float

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

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

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


float

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

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

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

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

Возвращает:

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

См. также:

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

species - вид требуемого вектора

a - массив

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

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

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

Возвращает:

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

Исключения:

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

См. также:

fromArray

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

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

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

Параметры:

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

a - массив

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

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

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

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

Возвращает:

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

Вызывает исключения:

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

См. также:

fromMemorySegment

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

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

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

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

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

fromMemorySegment

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

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

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

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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Параметры:

a - массив

offset - смещение, которое нужно объединить со смещениями карты индексов

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

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

Вызывает исключения:

См. также:

intoArray

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

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

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

Параметры:

a - массив

offset - смещение, которое нужно объединить со смещениями карты индексов

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

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

m - маска

Вызывает исключения:

См. также:

intoMemorySegment

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

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

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

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

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

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

intoMemorySegment

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

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

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

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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

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

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

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

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

public final int hashCode()

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

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

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Long> species()

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

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

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

check

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

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

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

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

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

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

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

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

Параметры:

species - требуемый тип вектора

Возвращает:

тот же вектор

См. также:

check

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

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

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

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

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Long> maskAll(boolean bit)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Задано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Задано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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

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

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

Задано в:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.