Класс FloatVector

java.lang.Object

jdk.incubator.vector.Vector<Float>

jdk.incubator.vector.FloatVector

public abstract class FloatVector extends Vector<Float>

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

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

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

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

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

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

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

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

Модификатор и тип	Метод	Описание
`final FloatVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final FloatVector`	`add(float e)`	Добавляет этот вектор к трансляции входного скаляра.
`final FloatVector`	`add(float e, VectorMask<Float> m)`	Добавляет этот вектор к трансляции входного скаляра, выбирая элементы канала, управляемые маской.
`final FloatVector`	`add(Vector<Float> v)`	Добавляет этот вектор ко второму входному вектору.
`final FloatVector`	`add(Vector<Float> v, VectorMask<Float> m)`	Добавляет этот вектор ко второму входному вектору, выбирая каналы под управлением маски.
`abstract FloatVector`	`addIndex(int scale)`	Добавляет каналы этого вектора к их соответствующим номерам канала, масштабируя их заданным константом.
`final FloatVector`	`blend(float e, VectorMask<Float> m)`	Заменяет выбранные каналы этого вектора скалярным значением под управлением маски.
`final FloatVector`	`blend(long e, VectorMask<Float> m)`	Заменяет выбранные каналы этого вектора скалярным значением под управлением маски.
`abstract FloatVector`	`blend(Vector<Float> v, VectorMask<Float> m)`	Заменяет выбранные каналы этого вектора соответствующими каналами из второго входного вектора под управлением маски.
`abstract FloatVector`	`broadcast(float e)`	Возвращает вектор того же типа, что и этот, где все элементы канала установлены в примитивное значение `e`.
`abstract FloatVector`	`broadcast(long e)`	Возвращает вектор того же типа, что и этот, где все элементы канала установлены в примитивное значение `e`.
`static FloatVector`	`broadcast(VectorSpecies<Float> species, float e)`	Возвращает вектор заданного типа, где все элементы канала установлены в примитивное значение `e`.
`static FloatVector`	`broadcast(VectorSpecies<Float> 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<Float>`	`compare(VectorOperators.Comparison op, float e)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Float>`	`compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения, в каналах, выбранных маской.
`abstract VectorMask<Float>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Float>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Float> m)`	Тестирует этот вектор, сравнивая его со входным скаляром в соответствии с заданной операцией сравнения, в каналах, выбранных маской.
`abstract VectorMask<Float>`	`compare(VectorOperators.Comparison op, Vector<Float> v)`	Тестирует этот вектор, сравнивая его с другим входным вектором, в соответствии с заданной операцией сравнения.
`abstract FloatVector`	`compress(VectorMask<Float> m)`	Сжимает элементы канала этого вектора, выбирая каналы под управлением определенной маски.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Float,F> conv, int part)`	Преобразует этот вектор в вектор той же формы и нового типа элемента, преобразуя значения каналов из текущего `ETYPE` в новый тип канала (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Float,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного типа, формы и типа элемента, преобразуя значения каналов из текущего `ETYPE` в новый тип канала (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`final FloatVector`	`div(float e)`	Делит этот вектор на трансляцию входного скаляра.
`final FloatVector`	`div(float e, VectorMask<Float> m)`	Делит этот вектор на трансляцию входного скаляра, выбирая элементы канала, управляемые маской.
`final FloatVector`	`div(Vector<Float> v)`	Делит этот вектор на второй входной вектор.
`final FloatVector`	`div(Vector<Float> v, VectorMask<Float> m)`	Делит этот вектор на второй входной вектор под управлением маски.
`final VectorMask<Float>`	`eq(float e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Float>`	`eq(Vector<Float> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`abstract FloatVector`	`expand(VectorMask<Float> m)`	Расширяет элементы канала этого вектора под управлением определенной маски.
`final FloatVector`	`fma(float b, float c)`	Умножает этот вектор на скалярный множитель и складывает результат со скалярным слагаемым.
`final FloatVector`	`fma(Vector<Float> b, Vector<Float> c)`	Умножает этот вектор на второй входной вектор и складывает результат с третьим.
`static FloatVector`	`fromArray(VectorSpecies<Float> species, float[] a, int offset)`	Загружает вектор из массива типа `float[]`, начиная со смещения.
`static FloatVector`	`fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)`	Собирает новый вектор, составленный из элементов массива типа `float[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static FloatVector`	`fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)`	Собирает новый вектор, составленный из элементов массива типа `float[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`static FloatVector`	`fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)`	Загружает вектор из массива типа `float[]`, начиная со смещения, и используя маску.
`static FloatVector`	`fromMemorySegment(VectorSpecies<Float> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти^ПРЕВЬЮ, начиная со смещения в сегменте памяти.
`static FloatVector`	`fromMemorySegment(VectorSpecies<Float> species, MemorySegment^PREVIEW ms, long offset, ByteOrder bo, VectorMask<Float> m)`	Загружает вектор из сегмента памяти^ПРЕВЬЮ, начиная со смещения в сегменте памяти, и используя маску.
`protected final Object`	`getPayload()`
`final int`	`hashCode()`	Возвращает хэш-код для вектора.
`final void`	`intoArray(float[] a, int offset)`	Сохраняет этот вектор в массив типа `float[]`, начиная со смещения.
`final void`	`intoArray(float[] a, int offset, int[] indexMap, int mapOffset)`	Разбрасывает этот вектор по массиву типа `float[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`final void`	`intoArray(float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)`	Разбрасывает этот вектор по массиву типа `float[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений от карты индексов.
`final void`	`intoArray(float[] a, int offset, VectorMask<Float> m)`	Сохраняет этот вектор в массив типа `float[]`, начиная со смещения, и используя маску.
`final void`	`intoMemorySegment(MemorySegment^PREVIEW ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти^ПРЕВЬЮ, начиная со смещения, с использованием явного порядка байт.

`final void`	`intoMemorySegment(MemorySegment^PREVIEW ms, long offset, ByteOrder bo, VectorMask<Float> m)`	Сохраняет этот вектор в сегменте памяти^{ПРЕДПРОСМОТР}, начиная с определенного смещения, используя явное порядок байтов и маску.
`abstract float`	`lane(int i)`	Получает элемент в аллели по индексу аллели `i`
`final FloatVector`	`lanewise(VectorOperators.Binary op, float e)`	Объединяет значения аллелей этого вектора со значением широковещательного скаляра.
`final FloatVector`	`lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m)`	Объединяет значения аллелей этого вектора со значением широковещательного скаляра, с выбором элементов аллелей, управляемых маской.
`final FloatVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения аллелей этого вектора со значением широковещательного скаляра.
`final FloatVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Float> m)`	Объединяет соответствующие значения аллелей этого вектора со значениями второго входного вектора, с выбором элементов аллелей, управляемых маской.
`abstract FloatVector`	`lanewise(VectorOperators.Binary op, Vector<Float> v)`	Объединяет соответствующие значения аллелей этого вектора со значениями второго входного вектора.
`abstract FloatVector`	`lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> m)`	Объединяет соответствующие значения аллелей этого вектора со значениями второго входного вектора, с выбором элементов аллелей, управляемых маской.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, float e1, float e2)`	Объединяет значения аллелей этого вектора со значениями двух широковещательных скаляров.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)`	Объединяет значения аллелей этого вектора со значениями двух широковещательных скаляров, с выбором элементов аллелей, управляемых маской.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)`	Объединяет значения аллелей этого вектора со значениями другого вектора и широковещательного скаляра.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)`	Объединяет значения аллелей этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов аллелей, управляемых маской.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2)`	Объединяет значения аллелей этого вектора со значениями другого вектора и широковещательного скаляра.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)`	Объединяет значения аллелей этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов аллелей, управляемых маской.
`abstract FloatVector`	`lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2)`	Объединяет соответствующие значения аллелей этого вектора со значениями аллелей второго и третьего входных векторов.
`abstract FloatVector`	`lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)`	Объединяет соответствующие значения аллелей этого вектора со значениями аллелей второго и третьего входных векторов, с выбором элементов аллелей, управляемых маской.
`abstract FloatVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операцию над значениями аллелей этого вектора.
`abstract FloatVector`	`lanewise(VectorOperators.Unary op, VectorMask<Float> m)`	Осуществляет операцию над значениями аллелей этого вектора, с выбором элементов аллелей, управляемых маской.
`final VectorMask<Float>`	`lt(float e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Float>`	`lt(Vector<Float> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Float>`	`maskAll(boolean bit)`	Возвращает маску того же типа, что и этот вектор, где каждая аллель установлена или не установлена в соответствии с заданным одиночным булевым значением, которое транслируется во все аллели.
`final FloatVector`	`max(float e)`	Вычисляет большее из этого вектора и широковещательной передачи входного скаляра.
`final FloatVector`	`max(Vector<Float> v)`	Вычисляет большее из этого вектора и второго входного вектора.
`final FloatVector`	`min(float e)`	Вычисляет меньшее из этого вектора и широковещательной передачи входного скаляра.
`final FloatVector`	`min(Vector<Float> v)`	Вычисляет меньшее из этого вектора и второго входного вектора.
`final FloatVector`	`mul(float e)`	Умножает этот вектор на широковещательную передачу входного скаляра.
`final FloatVector`	`mul(float e, VectorMask<Float> m)`	Умножает этот вектор на широковещательную передачу входного скаляра, выбирая элементы аллелей, управляемые маской.
`final FloatVector`	`mul(Vector<Float> v)`	Умножает этот вектор на второй входной вектор.
`final FloatVector`	`mul(Vector<Float> v, VectorMask<Float> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final FloatVector`	`neg()`	Инвертирует этот вектор.
`final FloatVector`	`pow(float b)`	Возводит этот вектор в скалярную степень.
`final FloatVector`	`pow(Vector<Float> b)`	Возводит этот вектор в степень второго входного вектора.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> m)`	Переупорядочивает элементы аллелей этого вектора, выбирая аллели под управлением определенной перестановки.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> s, Vector<Float> v)`	Переупорядочивает элементы аллелей двух векторов, выбирая аллели под управлением определенной перестановки, используя как нормальные, так и исключительные индексы в перестановке для управления данными.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> s, VectorMask<Float> m)`	Переупорядочивает элементы аллелей этого вектора, выбирая аллели под управлением определенной перестановки и маски.
`abstract float`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное из всех аллелей этого вектора.
`abstract float`	`reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)`	Возвращает значение, накопленное из выбранных аллелей этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор с той же формой и содержимым, но типом аллели `byte`, где байты извлекаются из аллелей в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переосмысливает этот вектор как вектор с той же формой и содержимым, но типом аллели `double`, где аллели собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переосмысливает этот вектор как вектор с той же формой и содержимым, но типом аллели `float`, где аллели собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переосмысливает этот вектор как вектор с той же формой и содержимым, но типом аллели `int`, где аллели собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переосмысливает этот вектор как вектор с той же формой и содержимым, но типом аллели `long`, где аллели собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переосмысливает этот вектор как вектор с той же формой и содержимым, но типом аллели `short`, где аллели собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract FloatVector`	`selectFrom(Vector<Float> v)`	Используя значения индексов, хранящиеся в аллелях этого вектора, собрать значения, хранящиеся во втором векторе `v`.
`abstract FloatVector`	`selectFrom(Vector<Float> s, VectorMask<Float> m)`	Используя значения индексов, хранящиеся в аллелях этого вектора, собрать значения, хранящиеся во втором векторе, под управлением маски.
`abstract FloatVector`	`slice(int origin)`	Вырезает сегмент смежных аллелей, начиная с заданной `origin` аллели в текущем векторе.
`abstract FloatVector`	`slice(int origin, Vector<Float> v1)`	Вырезает сегмент смежных аллелей, начиная с заданной `origin` аллели в текущем векторе и продолжая (по мере необходимости) в непосредственно следующий вектор.
`final FloatVector`	`slice(int origin, Vector<Float> w, VectorMask<Float> m)`	Вырезает сегмент смежных аллелей под управлением маски, начиная с заданной `origin` аллели в текущем векторе и продолжая (по мере необходимости) в непосредственно следующий вектор.
`final VectorSpecies<Float>`	`species()`	Возвращает вид этого вектора.
`final FloatVector`	`sqrt()`	Вычисляет квадратный корень из этого вектора.

`final FloatVector`	`sub(float e)`	Вычитает скалярный входной параметр из этого вектора.
`final FloatVector`	`sub(float e, VectorMask<Float> m)`	Вычитает скалярный входной параметр из этого вектора под управлением маски.
`final FloatVector`	`sub(Vector<Float> v)`	Вычитает второй входной вектор из этого вектора.
`final FloatVector`	`sub(Vector<Float> v, VectorMask<Float> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Float>`	`test(VectorOperators.Test op)`	Проверяет элементы этого вектора в соответствии с заданной операцией.
`abstract VectorMask<Float>`	`test(VectorOperators.Test op, VectorMask<Float> m)`	Проверяет выбранные элементы этого вектора в соответствии с заданной операцией.
`final float[]`	`toArray()`	Возвращает массив типа `float[]`, содержащий все значения элементов.
`final double[]`	`toDoubleArray()`	Возвращает массив `double[]` содержащий все значения элементов, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив `int[]` содержащий все значения элементов, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает строковое представление этого вектора, вида `"[0,1,2...]"`, отображающее значения элементов этого вектора в порядке элементов.
`abstract FloatVector`	`unslice(int origin)`	Обращает срез slice(), вставляя текущий вектор в качестве среза в «фоновый» вход с нулевыми значениями элементов.
`abstract FloatVector`	`unslice(int origin, Vector<Float> w, int part)`	Обращает срез slice(), вставляя текущий вектор в качестве среза в другой «фоновый» входной вектор, рассматриваемый как один из входов гипотетической последующей `slice()` операции.
`abstract FloatVector`	`unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m)`	Обращает срез slice(), вставляя (под управлением маски) текущий вектор в качестве среза в другой «фоновый» входной вектор, рассматриваемый как один из входов гипотетической последующей `slice()` операции.
`final FloatVector`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор с такой же формой, длиной и содержимым, но типом элемента — плавающей точкой.
`final IntVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор с такой же формой, длиной и содержимым, но типом элемента, не являющимся типом с плавающей точкой.
`abstract FloatVector`	`withLane(int i, float e)`	Заменяет элемент в этом векторе по индексу элемента `i` значением `e`.
`static FloatVector`	`zero(VectorSpecies<Float> species)`	Возвращает вектор данного типа, где все элементы установлены в ноль — значение по умолчанию для примитивного типа.

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Float> SPECIES_64

Species, представляющий FloatVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Float> SPECIES_128

Species, представляющий FloatVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Float> SPECIES_256

Species, представляющий FloatVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Float> SPECIES_512

Species, представляющий FloatVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Float> SPECIES_MAX

Species, представляющий FloatVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Float> SPECIES_PREFERRED

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

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

zero

public static FloatVector zero(VectorSpecies<Float> species)

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

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

broadcast

public abstract FloatVector broadcast(float e)

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

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

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

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

Параметры:

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

Возвращаемое значение:

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

См. также:

broadcast

public static FloatVector broadcast(VectorSpecies<Float> species, float e)

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

Параметры:

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

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

Возвращаемое значение:

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

См. также:

broadcast

public abstract FloatVector broadcast(long e)

Этот метод возвращает значение этого выражения: EVector.broadcast(this.species(), (ETYPE)e), где EVector — это класс вектора, специфичный для типа элемента этого вектора ETYPE.

Значение long e должно точно представляться ETYPE species этого вектора, так что e==(long)(ETYPE)e. Если это правило нарушено, проблема не обнаруживается статически, но во время выполнения выбрасывается IllegalArgumentException. Таким образом, этот метод несколько ослабляет статическую проверку типов для непосредственных констант и других скаляров, но компенсирует это, повышая выразительность универсального API. Обратите внимание, что значение e в диапазоне [-128..127] всегда приемлемо, поскольку каждый ETYPE будет принимать каждое значение byte.

Указано в:

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

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

При работе с подтипами векторов, такими как FloatVector, чаще выбирается метод с более сильной типизацией. Его можно явно выбрать с помощью приведения типов: v.broadcast((float)e). Два выражения дадут численно идентичные результаты.

Параметры:

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

Возвращаемое значение:

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

См. также:

broadcast

public static FloatVector broadcast(VectorSpecies<Float> species, long e)

Возвращает вектор заданного species, где все элементы канала установлены в примитивное значение e. Значение long должно точно представляться ETYPE species вектора, так что e==(long)(ETYPE)e.

Параметры:

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

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

Возвращаемое значение:

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

Исключения:

IllegalArgumentException - если заданное значение long не может быть представлено ETYPE вектора

См. также:

lanewise

public abstract FloatVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

Возвращаемое значение:

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

См. также:

lanewise

public abstract FloatVector lanewise(VectorOperators.Unary op, VectorMask<Float> m)

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

Указано в:

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

Параметры:

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

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

Возвращаемое значение:

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

См. также:

lanewise

public abstract FloatVector lanewise(VectorOperators.Binary op, Vector<Float> v)

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

Указано в:

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

Параметры:

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

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

Возвращаемое значение:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Binary op, float e)

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

Параметры:

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Binary op, float e, VectorMask<Float> m)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

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

Указано в:

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

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

При работе с подтипами векторов, такими как FloatVector, обычно выбирается более типизированный метод более типизированный метод. Его можно явно выбрать с помощью приведения типов: v.lanewise(op,(float)e). Эти два выражения дадут численно идентичные результаты.

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

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

При работе с подтипами векторов, такими как FloatVector, обычно выбирается более типизированный метод более типизированный метод. Его можно явно выбрать с помощью приведения типов: v.lanewise(op,(float)e,m). Эти два выражения дадут численно идентичные результаты.

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public abstract FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2)

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, float e1, float e2)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, float e1, float e2, VectorMask<Float> m)

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2)

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> m)

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise

public final FloatVector lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> m)

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

add

public final FloatVector add(Vector<Float> v)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

add

public final FloatVector add(float e)

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

Параметры:

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

Возвращает:

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

См. также:

add

public final FloatVector add(Vector<Float> v, VectorMask<Float> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

add

public final FloatVector add(float e, VectorMask<Float> m)

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

Parameters:

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

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

Returns:

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

See Also:

sub

public final FloatVector sub(Vector<Float> v)

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

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

Specified by:

sub in class Vector<Float>

Parameters:

v - второй вектор ввода

Returns:

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

See Also:

sub

public final FloatVector sub(float e)

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

Parameters:

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

Returns:

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

See Also:

sub

public final FloatVector sub(Vector<Float> v, VectorMask<Float> m)

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

Specified by:

sub in class Vector<Float>

Parameters:

v - второй вектор ввода

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

Returns:

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

See Also:

sub

public final FloatVector sub(float e, VectorMask<Float> m)

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final FloatVector mul(Vector<Float> v)

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

Specified by:

mul in class Vector<Float>

Parameters:

v - второй вектор ввода

Returns:

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

See Also:

mul

public final FloatVector mul(float e)

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

Parameters:

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

Returns:

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

See Also:

mul

public final FloatVector mul(Vector<Float> v, VectorMask<Float> m)

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

Specified by:

mul in class Vector<Float>

Parameters:

v - второй вектор ввода

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

Returns:

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

See Also:

mul

public final FloatVector mul(float e, VectorMask<Float> m)

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

Parameters:

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

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

Returns:

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

See Also:

div

public final FloatVector div(Vector<Float> v)

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

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

Specified by:

div in class Vector<Float>

API Note:

Поскольку базовая скалярная операция является числом с плавающей точкой IEEE, деление на ноль фактически не вызовет исключения, а вернёт бесконечность или NaN со знаком.

Parameters:

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

Returns:

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

See Also:

div

public final FloatVector div(float e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

div

public final FloatVector div(Vector<Float> v, VectorMask<Float> m)

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

Specified by:

div in class Vector<Float>

API Note:

Parameters:

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

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

Returns:

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

See Also:

div

public final FloatVector div(float e, VectorMask<Float> m)

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

API Note:

Parameters:

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

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

Returns:

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

See Also:

min

public final FloatVector min(Vector<Float> v)

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

Specified by:

min in class Vector<Float>

API Note:

Для этого метода отрицательный ноль с плавающей точкой -0.0 рассматривается как значение, отличное от и меньшее, чем стандартное значение (положительный ноль).

Parameters:

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

Returns:

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

See Also:

min

public final FloatVector min(float e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

max

public final FloatVector max(Vector<Float> v)

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

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

Specified by:

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

API Note:

Для этого метода отрицательный ноль с плавающей точкой -0.0 рассматривается как значение, отличное от и меньшее по умолчанию (положительный ноль).

Parameters:

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

Returns:

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

See Also:

max

public final FloatVector max(float e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

pow

public final FloatVector pow(Vector<Float> b)

Возводит этот вектор в степень второго входного вектора. Это бинарная операция по элементам, которая применяет операцию, соответствующую спецификации Math.pow(a,b), к каждой паре соответствующих значений элементов. Операция адаптирована для преобразования операндов и результата, в частности, расширяет float операнды до double операндов и сужает double результат до float результата. Этот метод также эквивалентен выражению lanewise(POW, b).

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

Parameters:

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

Returns:

степень b этого вектора

See Also:

pow

public final FloatVector pow(float b)

Возводит этот вектор в скалярную степень. Это бинарная операция по элементам, которая применяет операцию, соответствующую спецификации Math.pow(a,b), к каждой паре соответствующих значений элементов. Операция адаптирована для преобразования операндов и результата, в частности, расширяет float операнды до double операндов и сужает double результат до float результата. Этот метод также эквивалентен выражению lanewise(POW, b).

Parameters:

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

Returns:

степень b этого вектора

See Also:

neg

public final FloatVector neg()

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

Specified by:

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

Returns:

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

See Also:

abs

public final FloatVector abs()

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

Specified by:

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

Returns:

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

See Also:

sqrt

public final FloatVector sqrt()

Вычисляет квадратный корень этого вектора. Это унарная операция по элементам, которая применяет операцию, соответствующую спецификации Math.sqrt(a), к каждому значению элемента. Операция адаптирована для преобразования операнда и результата, в частности, расширяет float операнд до double операнда и сужает double результат до float результата. Этот метод также эквивалентен выражению lanewise(SQRT).

Returns:

квадратный корень этого вектора

See Also:

eq

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

eq

public final VectorMask<Float> eq(float e)

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

Parameters:

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

Returns:

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

See Also:

lt

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Float> lt(float e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

public abstract VectorMask<Float> compare(VectorOperators.Comparison op, float e)

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

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

Параметры:

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

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

Возвращает:

См. также:

compare

public final VectorMask<Float> compare(VectorOperators.Comparison op, float e, VectorMask<Float> m)

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare

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

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

См. также:

blend

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

addIndex

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

blend

public final FloatVector blend(float e, VectorMask<Float> m)

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

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

blend

public final FloatVector blend(long e, VectorMask<Float> m)

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

slice

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

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

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

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

Параметры:

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

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

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

Возвращает:

См. также:

slice

public abstract FloatVector slice(int origin)

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


 (origin,

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

Параметры:

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

Возвращает:

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

См. также:

unslice

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

Параметры:

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

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

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

Возвращает:

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

См. также:

unslice

public abstract FloatVector unslice(int origin, Vector<Float> w, int part, VectorMask<Float> m)

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

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

Specified by:

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

Parameters:

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

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

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

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

Returns:

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

See Also:

unslice

public abstract FloatVector unslice(int origin)

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


 (origin,

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

rearrange

public abstract FloatVector rearrange(VectorShuffle<Float> m)

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

rearrange

public abstract FloatVector rearrange(VectorShuffle<Float> s, VectorMask<Float> m)

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

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


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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

rearrange

public abstract FloatVector rearrange(VectorShuffle<Float> s, Vector<Float> 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());

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

compress

public abstract FloatVector compress(VectorMask<Float> m)

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

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

expand

public abstract FloatVector expand(VectorMask<Float> m)

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

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

selectFrom

public abstract FloatVector selectFrom(Vector<Float> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

public abstract FloatVector selectFrom(Vector<Float> s, VectorMask<Float> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

fma

public final FloatVector fma(Vector<Float> b, Vector<Float> c)

Умножает этот вектор на второй входной вектор и суммирует результат с третьим. Для промежуточного результата используется расширенная точность, чтобы избежать возможной потери точности из-за округления при выполнении каждой из двух операций. Результат численно близок к this.mul(b).add(c), и обычно ближе к истинному математическому результату. Это троичная операция по элементам, которая применяет операцию, соответствующую спецификации Math.fma(a,b,c), к каждому элементу. Операция адаптирована для преобразования операндов и результата, в частности, расширяя float операнды до double операндов и сужая double результат до float результата. Этот метод также эквивалентен выражению lanewise(FMA, b, c).

Параметры:

b - второй входной вектор, предоставляющий значения множителей

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

Возвращает:

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

См. также:

fma

public final FloatVector fma(float b, float c)

Умножает этот вектор на скалярный множитель и суммирует результат со скалярным слагаемым. Для промежуточного результата используется расширенная точность, чтобы избежать возможной потери точности из-за округления при выполнении каждой из двух операций. Результат численно близок к this.mul(b).add(c), и обычно ближе к истинному математическому результату. Это троичная операция по элементам, которая применяет операцию, соответствующую спецификации Math.fma(a,b,c), к каждому элементу. Операция адаптирована для преобразования операндов и результата, в частности, расширяя float операнды до double операндов и сужая double результат до float результата. Этот метод также эквивалентен выражению lanewise(FMA, b, c).

Параметры:

b - скалярный множитель

c - скалярное слагаемое

Возвращает:

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

См. также:

reduceLanes

public abstract float reduceLanes(VectorOperators.Associative op)

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

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

В случае FIRST_NONZERO, сокращение возвращает значение из элемента с наименьшим номером, отличным от нуля. (Как и в случае MAX и MIN, отрицательный ноль с плавающей точкой -0.0 обрабатывается как значение, отличное от значения по умолчанию, положительного нуля. Таким образом, сокращение по первому ненулевому элементу может вернуть -0.0 даже при наличии ненулевых значений элементов.)
В случае ADD и MUL, точный результат будет отражать выбор произвольного порядка операций, который может даже меняться со временем. Для получения более подробной информации см. раздел Операции с векторами с плавающей точкой.
Все остальные операции сокращения полностью коммутативны и ассоциативны. Реализация может выбрать любой порядок обработки, но она всегда будет давать один и тот же результат.

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes

public abstract float reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)

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

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

Если операция — ADD или FIRST_NONZERO, то значение по умолчанию — положительный ноль, значение по умолчанию float.
Если операция — MUL, то значение по умолчанию — единица.
Если операция — MAX, то значение по умолчанию — Float.NEGATIVE_INFINITY.
Если операция — MIN, то значение по умолчанию — Float.POSITIVE_INFINITY.

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

В случае FIRST_NONZERO, редукция возвращает значение из элемента с наименьшим номером, отличным от нуля. (Как и в случае MAX и MIN, отрицательный ноль с плавающей точкой -0.0 обрабатывается как значение, отличное от значения по умолчанию, положительного нуля. Поэтому редукция первого ненулевого элемента может вернуть -0.0 даже при наличии ненулевых значений элементов.)
В случае ADD и MUL, точный результат будет отражать выбор произвольного порядка операций, который может даже меняться со временем. Для получения дополнительной информации см. раздел Операции над векторами с плавающей точкой.
Все остальные операции редукции полностью коммутативны и ассоциативны. Реализация может выбрать любой порядок обработки, но всегда произведёт тот же результат.

Parameters:

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

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

Returns:

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

Throws:

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

See Also:

lane

public abstract float lane(int i)

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

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

withLane

public abstract FloatVector withLane(int i, float e)

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

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

toArray

public final float[] toArray()

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

Specified by:

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

Returns:

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

See Also:

toIntArray

public final int[] toIntArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toLongArray

public final long[] toLongArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toDoubleArray

public final double[] toDoubleArray()

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

fromArray

public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset)

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

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

fromArray

public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)

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

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

fromArray

public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

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

See Also:

fromArray

public static FloatVector fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

See Also:

fromMemorySegment

public static FloatVector fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)

Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти. Байты объединяются в примитивные элементы элементов в соответствии с указанным порядком байтов. Вектор упорядочивается по элементам в соответствии с порядком памяти.

Этот метод ведет себя так, как если бы он возвращал результат вызова fromMemorySegment()^{ПРЕДПРОСМОТР} следующим образом:


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

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

fromMemorySegment

public static FloatVector fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Float> m)

Загружает вектор из сегмента памяти^{ПРЕДПРОСМОТР}, начиная со смещения в сегменте памяти и используя маску. Элементы, где маска не установлена, заполняются значениями по умолчанию float (положительный ноль). Байты объединяются в примитивные элементы элементов в соответствии с указанным порядком байтов. Вектор упорядочивается по элементам в соответствии с порядком памяти.

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


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

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

intoArray

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

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

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

Parameters:: a - массив типа float[]; offset - смещение в массиве
Throws:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любого элемента N в векторе

intoArray

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

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

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

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

Parameters:: a - массив типа float[]; offset - смещение в массиве; m - маска, контролирующая сохранение элементов
Throws:: IndexOutOfBoundsException - если offset+N < 0 или offset+N >= a.length для любого элемента N в векторе, где маска установлена

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

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

See Also:

intoMemorySegment

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

Хранит этот вектор в сегменте памяти^{ПРЕДПРОСМОТР}, начиная со смещения, используя явное порядок байтов.

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

Этот метод ведет себя так, как если бы он вызывал intoMemorySegment()^{ПРЕДПРОСМОТР} следующим образом:


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

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

intoMemorySegment

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

Хранит этот вектор в сегменте памяти^{ПРЕДПРОСМОТР}, начиная со смещения, используя явный порядок байтов и маску.

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Specified by:

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

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

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

See Also:

species

public final VectorSpecies<Float> species()

Description copied from class: Vector

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

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

check

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

Description copied from class: Vector

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

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

Specified by:

check in class Vector<E>

Type Parameters:

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

Parameters:

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

Returns:

тот же вектор

See Also:

check

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

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

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

Specified by:

check in class Vector<E>

Type Parameters:

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

Parameters:

elementType - требуемый тип прохода

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Float> maskAll(boolean bit)

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

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

Specified by:

maskAll in class Vector<E>

Parameters:

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

Returns:

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

See Also:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Определяется:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Определяется:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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


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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

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

Returns:

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

See Also:

getPayload

protected final Object getPayload()

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