Класс 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`; байты извлекаются из элементов в порядке от младшего к старшему.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `double`; элементы составляются из последовательных байтов в порядке от младшего к старшему.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `float`; элементы составляются из последовательных байтов в порядке от младшего к старшему.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `int`; элементы составляются из последовательных байтов в порядке от младшего к старшему.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `long`; элементы составляются из последовательных байтов в порядке от младшего к старшему.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов `short`; элементы составляются из последовательных байтов в порядке от младшего к старшему.
`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[]`	`toArray()`	Возвращает массив типа `float[]`, содержащий значения всех элементов.
`final double[]`	`toDoubleArray()`	Возвращает массив `double[]`, содержащий значения всех элементов, преобразованные к типу `double`.
`final int[]`	`toIntArray()`	Возвращает массив `int[]`, содержащий значения всех элементов, преобразованные к типу `int`.
`final long[]`	`toLongArray()`	Возвращает массив `long[]`, содержащий значения всех элементов, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора в формате `"[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)`	Возвращает вектор заданного вида, в котором всем элементам присвоено нулевое значение — значение примитивного типа по умолчанию.

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

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

Методы, объявленные в классе 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:

В отличие от похожего метода с именем 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:

При работе с подтипами вектора, например 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).

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final FloatVector sub(Vector<Float> v)

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final FloatVector sub(float e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final FloatVector mul(Vector<Float> v)

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final FloatVector mul(float e)

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

Параметры:

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

Возвращает:

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

См. также:

mul

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

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:

Параметры:

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

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 — смещение в карте индексов

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

См. также:

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

Указано в:

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

Представляет этот вектор как вектор той же формы, длины и содержимого, но с типом элемента, являющимся типом с плавающей точкой. Это переинтерпретирующее приведение значений элементов вектора. Поэтому этот метод не изменяет VSHAPE или VLENGTH и не меняет побитовое содержимое вектора. Если ETYPE вектора уже является типом с плавающей точкой, возвращается тот же вектор без изменений. Если размер элемента вектора не соответствует размеру ни одного типа с плавающей точкой, выбрасывается 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 — упакованный тип элементов требуемого типа lane

Параметры:

elementType — требуемый тип lane

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Float> maskAll(boolean bit)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

Совместное влияние изменения формы и размера lane может привести к тому, что входной и выходной виды будут иметь разное количество lane, вызывая расширение или сужение. В этом случае ненулевой параметр 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 — требуемое скалярное преобразование, применяемое к каждому lane

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://docs.oracle.com/en/java/javase/25/docs/api/jdk.incubator.vector/jdk/incubator/vector/FloatVector.html