Класс FloatVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

jdk.internal.vm.vector.VectorSupport.Vector<E>

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.FloatVector

public abstract class FloatVector extends Vector<E>

Специализированный 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)`	Проверяет этот вектор, сравнивая его с другим входным вектором, в соответствии с заданной операцией сравнения.
`final VectorMask<Float>`	`compare(VectorOperators.Comparison op, Vector<Float> v, 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)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`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`	`fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo)`	Загружает вектор из массива байтов, начиная со смещения.
`static FloatVector`	`fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)`	Загружает вектор из массива байтов, начиная со смещения и используя маску.
`static FloatVector`	`fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo)`	Загружает вектор из байтового буфера, начиная со смещения в байтовый буфер.
`static FloatVector`	`fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)`	Загружает вектор из байтового буфера, начиная со смещения в байтовый буфер и используя маску.
`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`	`intoByteArray(byte[] a, int offset, ByteOrder bo)`	Сохраняет этот вектор в массив байтов, начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)`	Сохраняет этот вектор в массив байтов, начиная со смещения, используя явное порядок байтов и маску.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)`	Сохраняет этот вектор в байтовый буфер, начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteBuffer(ByteBuffer bb, int 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)`	Объединяет соответствующие значения дорожек этого вектора со значениями второго входного вектора.
`final 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)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов.
`final FloatVector`	`lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> m)`	Объединяет соответствующие значения дорожек этого вектора с дорожками второго и третьего входных векторов, с выбором элементов дорожек, контролируемым маской.
`abstract FloatVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операцию над значениями дорожек этого вектора.
`final FloatVector`	`lanewise(VectorOperators.Unary op, VectorMask<Float> m)`	Осуществляет операцию над значениями дорожек этого вектора, с выбором элементов дорожек, контролируемым маской.
`final VectorMask<Float>`	`lt(float e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Float>`	`lt(Vector<Float> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Float>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор, где каждая дорожка установлена или сброшена в соответствии с заданным одиночным булевым значением, которое вещается на все дорожки.
`final FloatVector`	`max(float e)`	Вычисляет большее из этого вектора и вещаемого входного скаляра.
`final FloatVector`	`max(Vector<Float> v)`	Вычисляет большее из этого вектора и второго входного вектора.
`final FloatVector`	`min(float e)`	Вычисляет меньшее из этого вектора и вещаемого входного скаляра.
`final FloatVector`	`min(Vector<Float> v)`	Вычисляет меньшее из этого вектора и второго входного вектора.
`final FloatVector`	`mul(float e)`	Умножает этот вектор на вещаемый входной скаляр.
`final FloatVector`	`mul(float e, VectorMask<Float> m)`	Умножает этот вектор на вещаемый входной скаляр, выбирая элементы дорожек, управляемые маской.
`final FloatVector`	`mul(Vector<Float> v)`	Умножает этот вектор на второй входной вектор.
`final FloatVector`	`mul(Vector<Float> v, VectorMask<Float> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final FloatVector`	`neg()`	Изменяет знак этого вектора.
`final FloatVector`	`pow(float b)`	Возводит этот вектор в скалярную степень.
`final FloatVector`	`pow(Vector<Float> b)`	Возводит этот вектор в степень второго входного вектора.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> m)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определенного перемешивания.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> s, Vector<Float> v)`	Переупорядочивает элементы дорожек двух векторов, выбирая дорожки под управлением определенного перемешивания, используя как обычные, так и исключительные индексы в перемешивании для управления данными.
`abstract FloatVector`	`rearrange(VectorShuffle<Float> s, VectorMask<Float> m)`	Переупорядочивает элементы дорожек этого вектора, выбирая дорожки под управлением определенного перемешивания и маски.
`abstract float`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накапливаемое со всех дорожек этого вектора.
`abstract float`	`reduceLanes(VectorOperators.Associative op, VectorMask<Float> m)`	Возвращает значение, накапливаемое с выбранных дорожек этого вектора, управляемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и содержимого, но с типом дорожки `byte`, где байты извлекаются из дорожек в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `double`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `float`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `int`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `long`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом дорожки `short`, где дорожки собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract FloatVector`	`selectFrom(Vector<Float> v)`	Используя значения индексов, хранящиеся в дорожках этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`abstract FloatVector`	`selectFrom(Vector<Float> s, VectorMask<Float> m)`	Используя значения индексов, хранящиеся в дорожках этого вектора, собирает значения, хранящиеся во втором векторе, под управлением маски.
`abstract FloatVector`	`slice(int origin)`	Вырезает сегмент смежных дорожек, начиная с заданной `origin` дорожки в текущем векторе.
`abstract FloatVector`	`slice(int origin, Vector<Float> v1)`	Вырезает сегмент смежных дорожек, начиная с заданной `origin` дорожки в текущем векторе и продолжая (по мере необходимости) в непосредственно следующий вектор.
`final FloatVector`	`slice(int origin, Vector<Float> w, VectorMask<Float> m)`	Вырезает сегмент смежных дорожек под управлением маски, начиная с заданной `origin` дорожки в текущем векторе и продолжая (по мере необходимости) в непосредственно следующий вектор.
`final VectorSpecies<Float>`	`species()`	Возвращает вид этого вектора.
`final FloatVector`	`sqrt()`	Вычисляет квадратный корень из этого вектора.
`final FloatVector`	`sub(float e)`	Вычитает входной скаляр из этого вектора.
`final FloatVector`	`sub(float e, VectorMask<Float> m)`	Вычитает входной скаляр из этого вектора под управлением маски.

END_OF_DOCUMENT_MARKER

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

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

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

Методы, объявленные в классе jdk.internal.vm.vector.VectorSupport.VectorPayload

getPayload

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

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

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

SPECIES_64

public static final VectorSpecies<Float> SPECIES_64

Species representing FloatVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Float> SPECIES_128

Species representing FloatVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Float> SPECIES_256

Species representing FloatVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Float> SPECIES_512

Species representing FloatVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Float> SPECIES_MAX

Species representing FloatVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Float> SPECIES_PREFERRED

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

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

zero

public static FloatVector zero(VectorSpecies<Float> species)

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

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

broadcast

public abstract FloatVector broadcast(float e)

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

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

API Note:

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

Параметры:

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

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

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

См. также:

broadcast

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

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

Параметры:

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

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

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

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

См. также:

broadcast

public abstract FloatVector broadcast(long e)

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

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

Указано в:

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

API Note:

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

Параметры:

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

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

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

См. также:

broadcast

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

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

Параметры:

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

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

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

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

Исключения:

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

См. также:

lanewise

public abstract FloatVector lanewise(VectorOperators.Unary op)

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

Указано в:

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

Параметры:

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

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

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

См. также:

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

См. также:

lanewise(VectorOperators.Binary,float)
lanewise(VectorOperators.Binary,float,VectorMask)

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,float,VectorMask)

lanewise

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

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

Параметры:

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

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

Возвращает:

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

Исключение:

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

См. также:

lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float,VectorMask)

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(VectorOperators.Binary,Vector,VectorMask)
lanewise(VectorOperators.Binary,float)

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(VectorOperators.Ternary,float,float,VectorMask)
lanewise(VectorOperators.Ternary,Vector,float,VectorMask)
lanewise(VectorOperators.Ternary,float,Vector,VectorMask)
lanewise(VectorOperators.Ternary,float,float)
lanewise(VectorOperators.Ternary,Vector,float)
lanewise(VectorOperators.Ternary,float,Vector)

lanewise

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

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

Указано в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Ternary,float,float,VectorMask)
lanewise(VectorOperators.Ternary,Vector,float,VectorMask)
lanewise(VectorOperators.Ternary,float,Vector,VectorMask)

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(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,float,float,VectorMask)

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(VectorOperators.Ternary,Vector,Vector,VectorMask)
lanewise(VectorOperators.Ternary,float,float)

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(VectorOperators.Ternary,float,float)
lanewise(VectorOperators.Ternary,Vector,float,VectorMask)

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(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,float,float,VectorMask)
lanewise(VectorOperators.Ternary,Vector,float)

lanewise

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

Параметры:

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

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

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

Возвращает:

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

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

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

См. также:

lanewise(VectorOperators.Ternary,Vector,Vector)
lanewise(VectorOperators.Ternary,float,Vector,VectorMask)

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

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

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

См. также:

lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)
lanewise(VectorOperators.Ternary,float,Vector)

add

public final FloatVector add(Vector<Float> v)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

add(float)

add

public final FloatVector add(float e)

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

Параметры:

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

Возвращает:

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

См. также:

add(Vector)
broadcast(float)
add(float,VectorMask)
VectorOperators.ADD
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

add

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

add(float,VectorMask)

add

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

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

Parameters:

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

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

Returns:

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

See Also:

add(Vector,VectorMask)
broadcast(float)
add(float)
VectorOperators.ADD
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

sub

public final FloatVector sub(Vector<Float> v)

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

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

Specified by:

sub in class Vector<Float>

Parameters:

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

Returns:

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

See Also:

sub(float)

sub

public final FloatVector sub(float e)

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

Parameters:

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

Returns:

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

See Also:

sub(Vector)
broadcast(float)
sub(float,VectorMask)
VectorOperators.SUB
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

sub

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

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

Specified by:

sub in class Vector<Float>

Parameters:

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

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

Returns:

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

See Also:

sub(float,VectorMask)

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

sub(Vector,VectorMask)
broadcast(float)
sub(float)
VectorOperators.SUB
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

mul

public final FloatVector mul(Vector<Float> v)

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

Specified by:

mul in class Vector<Float>

Parameters:

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

Returns:

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

See Also:

mul(float)

mul

public final FloatVector mul(float e)

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

Parameters:

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

Returns:

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

See Also:

mul(Vector)
broadcast(float)
mul(float,VectorMask)
VectorOperators.MUL
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

mul

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

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

Specified by:

mul in class Vector<Float>

Parameters:

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

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

Returns:

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

See Also:

mul(float,VectorMask)

END_OF_DOCUMENT_MARKER

mul

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

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

Parameters:

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

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

Returns:

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

See Also:

mul(Vector,VectorMask)
broadcast(float)
mul(float)
VectorOperators.MUL
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

div

public final FloatVector div(Vector<Float> v)

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

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

Specified by:

div in class Vector<Float>

API Note:

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

Parameters:

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

Returns:

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

See Also:

div

public final FloatVector div(float e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

div(Vector)
broadcast(float)
div(float,VectorMask)
VectorOperators.DIV
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

div

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

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

Specified by:

div in class Vector<Float>

API Note:

Parameters:

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

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

Returns:

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

See Also:

div(float,VectorMask)

div

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

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

API Note:

Parameters:

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

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

Returns:

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

See Also:

div(Vector,VectorMask)
broadcast(float)
div(float)
VectorOperators.DIV
lanewise(VectorOperators.Binary,Vector)
lanewise(VectorOperators.Binary,float)

min

public final FloatVector min(Vector<Float> v)

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

Specified by:

min in class Vector<Float>

API Note:

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

Parameters:

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

Returns:

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

See Also:

min

public final FloatVector min(float e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

min(Vector)
broadcast(float)
VectorOperators.MIN
lanewise(VectorOperators.Binary,float,VectorMask)

max

public final FloatVector max(Vector<Float> v)

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

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final FloatVector max(float e)

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

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

Параметры:

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

Возвращает:

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

См. также:

max(Vector)
broadcast(float)
VectorOperators.MAX
lanewise(VectorOperators.Binary,float,VectorMask)

pow

public final FloatVector pow(Vector<Float> b)

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

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

Параметры:

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

Возвращает:

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

См. также:

pow(float)
VectorOperators.POW
lanewise(VectorOperators.Binary,Vector,VectorMask)

pow

public final FloatVector pow(float b)

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

Параметры:

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

Возвращает:

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

См. также:

pow(Vector)
VectorOperators.POW
lanewise(VectorOperators.Binary,float,VectorMask)

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

Возвращает:

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

См. также:

VectorOperators.SQRT
lanewise(VectorOperators.Unary,VectorMask)

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

См. также:

compare(VectorOperators.Comparison,float)

lt

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

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

Specified by:

lt in class Vector<Float>

Parameters:

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

Returns:

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

See Also:

lt

public final VectorMask<Float> lt(float e)

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

Parameters:

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

Returns:

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

See Also:

compare(VectorOperators.Comparison,float)

test

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

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

Specified by:

test in class Vector<Float>

Parameters:

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

Returns:

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

See Also:

test

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

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

Specified by:

test in class Vector<Float>

Parameters:

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

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

Returns:

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

See Also:

Vector.test(VectorOperators.Test)

compare

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

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

Specified by:

compare in class Vector<Float>

Parameters:

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

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

Returns:

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

See Also:

compare

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

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

Specified by:

compare in class Vector<Float>

Parameters:

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

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

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

Returns:

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

See Also:

Vector.compare(VectorOperators.Comparison, Vector)

compare

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

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

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

Parameters:

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

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

Returns:

See Also:

compare(VectorOperators.Comparison,Vector)
eq(float)
lt(float)

compare

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

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

Parameters:

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

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

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

Returns:

See Also:

compare(VectorOperators.Comparison,Vector,VectorMask)

compare

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

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

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

Specified by:

compare in class Vector<Float>

Parameters:

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

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

Returns:

See Also:

compare

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

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

Specified by:

compare in class Vector<Float>

Parameters:

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

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

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

Returns:

See Also:

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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


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

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

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 - второй входной вектор

Возвращает:

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

См. также:

selectFrom

public abstract FloatVector selectFrom(Vector<Float> v)

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

Vector.rearrange(VectorShuffle)

selectFrom

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

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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

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

Parameters:

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

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

Returns:

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

See Also:

fma(float,float)
VectorOperators.FMA
lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)

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

Parameters:

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

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

Returns:

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

See Also:

fma(Vector,Vector)
VectorOperators.FMA
lanewise(VectorOperators.Ternary,float,float,VectorMask)

reduceLanes

public abstract float reduceLanes(VectorOperators.Associative op)

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

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

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

Parameters:

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

Returns:

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

Throws:

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

See Also:

reduceLanes(VectorOperators.Associative,VectorMask)
add(Vector)
mul(Vector)
min(Vector)
max(Vector)
VectorOperators.FIRST_NONZERO

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 - если этот вектор не поддерживает запрошенную операцию

См. также:

reduceLanes(VectorOperators.Associative)

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

См. также:

fromByteArray

public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo)

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

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


 var bb = ByteBuffer.wrap(a);
 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

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

fromByteArray

public static FloatVector fromByteArray(VectorSpecies<Float> species, byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)

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

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


 var bb = ByteBuffer.wrap(a);
 return fromByteBuffer(species, bb, offset, bo, m);

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

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

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

See Also:

toIntArray()

fromArray

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

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

See Also:

toIntArray()

fromByteBuffer

public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo)

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

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


 var m = species.maskAll(true);
 return fromByteBuffer(species, bb, offset, bo, m);

Parameters:: species - вид желаемого вектора; bb - байтовый буфер; offset - смещение в байтовом буфере; bo - предполагаемый порядок байтов
Returns:: вектор, загруженный из байтового буфера
Throws:: IndexOutOfBoundsException - если offset+N*4 < 0 или offset+N*4 >= bb.limit() для любого разряда N в векторе

fromByteBuffer

public static FloatVector fromByteBuffer(VectorSpecies<Float> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)

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

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


 FloatBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asFloatBuffer();
 float[] ar = new float[species.length()];
 for (int n = 0; n < ar.length; n++) {
     if (m.laneIsSet(n)) {
         ar[n] = eb.get(n);
     }
 }
 FloatVector r = FloatVector.fromArray(species, ar, 0);

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

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

See Also:

toIntArray()

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

toIntArray()

intoByteArray

public final void intoByteArray(byte[] a, int offset, ByteOrder bo)

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

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

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


 var bb = ByteBuffer.wrap(a);
 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

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

intoByteArray

public final void intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Float> m)

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

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


 var bb = ByteBuffer.wrap(a);
 intoByteBuffer(bb, offset, bo, m);

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

intoByteBuffer

public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)

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

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


 var m = maskAll(true);
 intoByteBuffer(bb, offset, bo, m);

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

intoByteBuffer

public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Float> m)

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

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


 EBuffer eb = bb.duplicate()
     .position(offset)
     .order(bo).asEBuffer();
 ETYPE[] a = this.toArray();
 for (int n = 0; n < a.length; n++) {
     if (m.laneIsSet(n)) {
         eb.put(n, a[n]);
     }
 }

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


 ByteBuffer eb = bb.duplicate()
     .position(offset);

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final IntVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final FloatVector viewAsFloatingLanes()

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

Возвращает:

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

См. также:

Vector.eq(jdk.incubator.vector.Vector<E>)

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 - заданный бит маски для репликации

Возвращает:

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

См. также:

VectorSpecies.maskAll(boolean)

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

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

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

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

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

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

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

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

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

castShape

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

convertShape

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

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

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

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

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


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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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