Класс FloatVector

java.lang.Object

jdk.incubator.vector.Vector<Float>

jdk.incubator.vector.FloatVector

public abstract sealed 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

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

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

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

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

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

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)

Объединяет значения элементов этого вектора со значениями другой векторной и скалярной величин, распространяемой по вектору. Это поэлементная тернарная операция, применяющая выбранную операцию к каждому элементу. Возвращаемое значение будет равно следующему выражению: this.lanewise(op, this.broadcast(e1), 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 — упакованный тип элементов требуемого типа элементов вектора

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Float> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом элементов double; элементы составляются из последовательных байтов в порядке 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)

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

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

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

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

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

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

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

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

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

Сохранение формы может потребовать выбора или вставки

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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