Класс FloatVector

java.lang.Object

jdk.incubator.vector.Vector<Float>

jdk.incubator.vector.FloatVector

public abstract class FloatVector extends Vector<Float>

Специализированный 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 ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная со смещения в сегмент памяти.
`static FloatVector`	`fromMemorySegment(VectorSpecies<Float> species, MemorySegment 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 ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная со смещения, используя явную битовую последовательность.
`final void`	`intoMemorySegment(MemorySegment 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> shuffle)`	Переупорядочивает элементы проходов этого вектора, выбирая проходы под управлением определенного перемещения.
`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> v1, Vector<Float> v2)`	Используя значения, хранящиеся в проходах этого вектора, собирает значения, хранящиеся во втором векторе `v1` и третьем векторе `v2`.
`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[]`	`test(VectorOperators.Test op, VectorMask<Float> m)`	Возвращает массив типа `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

Вид, представляющий FloatVector из VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Float> SPECIES_128

Вид, представляющий FloatVector из VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Float> SPECIES_256

Вид, представляющий FloatVector из VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Float> SPECIES_512

Вид, представляющий FloatVector из VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Float> SPECIES_MAX

Вид, представляющий FloatVector из VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Float> SPECIES_PREFERRED

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

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

zero

public static FloatVector zero(VectorSpecies<Float> species)

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

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

broadcast

public abstract FloatVector broadcast(float e)

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

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

API Note:

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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

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

Возвращает:

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

См. также:

broadcast

public abstract FloatVector broadcast(long e)

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

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

Указано в:

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

API Note:

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

Параметры:

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

Возвращает:

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

См. также:

broadcast

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

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

Параметры:

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:

умн

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

public final FloatVector div(Vector<Float> v)

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

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

div

public final FloatVector div(float e)

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

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

Параметры:

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

Возвращает:

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

См. также:

div

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

min

public final FloatVector min(Vector<Float> v)

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final FloatVector min(float e)

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final FloatVector max(Vector<Float> v)

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

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final FloatVector max(float e)

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

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

Параметры:

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

Возвращает:

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

См. также:

pow

public final FloatVector pow(Vector<Float> b)

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

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

Параметры:

b - векторный показатель степени, в который нужно возвести этот вектор

Возвращает:

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

См. также:

pow

public final FloatVector pow(float b)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final FloatVector neg()

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

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

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

Возвращает:

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

См. также:

abs

public final FloatVector abs()

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

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

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

Возвращает:

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

См. также:

sqrt

public final FloatVector sqrt()

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

Возвращает:

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

См. также:

eq

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Float> eq(float e)

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

Параметры:

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

Возвращает:

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

См. также:

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, равное нулю или единице, выбирает первый или второй обновленный фоновый вектор.

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract FloatVector unslice(int origin)

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


 (origin,

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract FloatVector rearrange(VectorShuffle<Float> shuffle)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compress

public abstract FloatVector compress(VectorMask<Float> m)

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

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

expand

public abstract FloatVector expand(VectorMask<Float> m)

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

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

selectFrom

public abstract FloatVector selectFrom(Vector<Float> v)

Используя значения индексов, хранящихся в дорожках этого вектора, собирает значения, хранящиеся во втором векторе v. Таким образом, второй вектор служит таблицей, элементы которой выбираются по индексам в текущем векторе. Это междорожечная операция, которая переупорядочивает элементы дорожек аргументного вектора под управлением этого вектора. Для каждой дорожки N этого вектора и для каждого значения дорожки I=wrapIndex(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

См. также:

selectFrom

public abstract FloatVector selectFrom(Vector<Float> v1, Vector<Float> v2)

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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 точный результат будет отражать выбор произвольного порядка операций, который может даже меняться со временем. Подробности см. в разделе Операции с векторами с плавающей точкой.
Все остальные операции сокращения полностью коммутативны и ассоциативны. Реализация может выбрать любой порядок обработки, но всегда будет возвращать одинаковый результат.

Параметры:

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

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

Возвращает:

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

Изначает:

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

См. также:

lane

public abstract float lane(int i)

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

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

withLane

public abstract FloatVector withLane(int i, float e)

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

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

toArray

public final float[] toArray()

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

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


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

Указано в:

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


 float

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

Указано в:

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


 float

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

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

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

При использовании данного метода для векторов типа FloatVector потеря точности не произойдёт.

Возвращает:

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

См. также:

fromArray

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

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

Параметры:: species - вид желаемого вектора; a - массив; offset - смещение в массиве
Возвращает:: вектор, загруженный из массива
Исключения:: 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.

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

См. также:

fromMemorySegment

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

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

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


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

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

END_OF_DOCUMENT_MARKER

fromMemorySegment

public static FloatVector fromMemorySegment(VectorSpecies<Float> species, MemorySegment 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);

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

intoArray

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

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

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

Параметры:: a - массив, типа float[]; offset - смещение в массиве
Исключения:: 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. То есть, не установленные ячейки могут соответствовать индексам массива меньше нуля или за пределами массива.

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

Параметры:

a - массив

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

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

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

Исключения:

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

См. также:

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

Параметры:

a - массив

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

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

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

m - маска

Исключения:

См. также:

intoMemorySegment

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

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

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

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


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

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

intoMemorySegment

public final void intoMemorySegment(MemorySegment 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);
     }
 }

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Указано в:

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

public final int hashCode()

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

Указано в:

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Float> species()

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

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

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

check

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

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Float> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

bit - заданное значение маски, которое должно быть продублировано

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

Specified by:

convert in class Vector<E>

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

castShape

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

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

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

Specified by:

castShape in class Vector<E>

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

END_OF_DOCUMENT_MARKER

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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