Класс DoubleVector

java.lang.Object

jdk.incubator.vector.Vector<Double>

jdk.incubator.vector.DoubleVector

public abstract class DoubleVector extends Vector<Double>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Double> SPECIES_64

Видовое представление DoubleVector типов VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Double> SPECIES_128

Видовое представление DoubleVector типов VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Double> SPECIES_256

Видовое представление DoubleVector типов VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Double> SPECIES_512

Видовое представление DoubleVector типов VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Double> SPECIES_MAX

Видовое представление DoubleVector типов VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Double> SPECIES_PREFERRED

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

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

zero

public static DoubleVector zero(VectorSpecies<Double> species)

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

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

broadcast

public abstract DoubleVector broadcast(double e)

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

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

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

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

Параметры:

e - значение для трансляции

Возвращает:

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

См. также:

broadcast

public static DoubleVector broadcast(VectorSpecies<Double> species, double e)

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

Параметры:

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

e - значение для трансляции

Возвращает:

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

См. также:

broadcast

public abstract DoubleVector broadcast(long e)

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

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

Задано:

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

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

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

Параметры:

e - значение для трансляции

Возвращает:

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

См. также:

broadcast

public static DoubleVector broadcast(VectorSpecies<Double> species, long e)

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

Параметры:

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

e - значение для трансляции

Возвращает:

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

Исключения:

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

См. также:

lanewise

public abstract DoubleVector lanewise(VectorOperators.Unary op)

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

Задано:

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

public abstract DoubleVector lanewise(VectorOperators.Unary op, VectorMask<Double> m)

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

Задано:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

public abstract DoubleVector lanewise(VectorOperators.Binary op, Vector<Double> v)

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

Задано:

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Binary op, double e)

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Binary op, double e, VectorMask<Double> m)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Примечние API:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public abstract DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2)

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, double e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, double e2, VectorMask<Double> m)

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

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> m)

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

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2)

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

lanewise

public final DoubleVector lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> m)

Параметры:

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

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

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

m - маска для выбора элементов

Возвращает:

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

Исключения:

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

См. также:

add

public final DoubleVector add(Vector<Double> v)

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

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

Унаследовано от:

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

Параметры:

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

Возвращает:

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

См. также:

add

public final DoubleVector add(double e)

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

Параметры:

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

Возвращает:

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

См. также:

add

public final DoubleVector add(Vector<Double> v, VectorMask<Double> m)

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

Унаследовано от:

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

Параметры:

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

m - маска для выбора элементов

Возвращает:

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

См. также:

add

public final DoubleVector add(double e, VectorMask<Double> m)

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

Parameters:

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

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

Returns:

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

See Also:

sub

public final DoubleVector sub(Vector<Double> v)

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

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

Specified by:

sub in class Vector<Double>

Parameters:

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

Returns:

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

See Also:

sub

public final DoubleVector sub(double e)

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

Parameters:

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

Returns:

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

See Also:

sub

public final DoubleVector sub(Vector<Double> v, VectorMask<Double> m)

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

Specified by:

sub in class Vector<Double>

Parameters:

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

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

Returns:

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

See Also:

sub

public final DoubleVector sub(double e, VectorMask<Double> m)

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

Parameters:

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

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

Returns:

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

See Also:

mul

public final DoubleVector mul(Vector<Double> v)

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

Specified by:

mul in class Vector<Double>

Parameters:

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

Returns:

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

See Also:

mul

public final DoubleVector mul(double e)

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

Parameters:

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

Returns:

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

See Also:

mul

public final DoubleVector mul(Vector<Double> v, VectorMask<Double> m)

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

Specified by:

mul in class Vector<Double>

Parameters:

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

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

Returns:

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

See Also:

умножение

public final DoubleVector mul(double e, VectorMask<Double> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

деление

public final DoubleVector div(Vector<Double> v)

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

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

деление

public final DoubleVector div(double e)

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

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

Параметры:

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

Возвращает:

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

См. также:

деление

public final DoubleVector div(Vector<Double> v, VectorMask<Double> m)

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

деление

public final DoubleVector div(double e, VectorMask<Double> m)

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

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

Параметры:

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

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

Возвращает:

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

См. также:

min

public final DoubleVector min(Vector<Double> v)

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

min

public final DoubleVector min(double e)

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final DoubleVector max(Vector<Double> v)

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

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

Specified by:

max in class Vector<Double>

API Note:

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

Parameters:

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

Returns:

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

See Also:

max

public final DoubleVector max(double e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

pow

public final DoubleVector pow(Vector<Double> b)

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

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

Parameters:

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

Returns:

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

See Also:

pow

public final DoubleVector pow(double b)

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

Parameters:

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

Returns:

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

See Also:

neg

public final DoubleVector neg()

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

Specified by:

neg in class Vector<Double>

Returns:

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

See Also:

abs

public final DoubleVector abs()

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

Specified by:

abs in class Vector<Double>

Returns:

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

See Also:

sqrt

public final DoubleVector sqrt()

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

Returns:

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

See Also:

eq

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

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

Specified by:

eq in class Vector<Double>

Parameters:

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

Returns:

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

See Also:

eq

public final VectorMask<Double> eq(double e)

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

Parameters:

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

Returns:

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

See Also:

lt

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Double> lt(double e)

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

public abstract VectorMask<Double> compare(VectorOperators.Comparison op, double e)

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

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

Параметры:

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

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

Возвращает:

См. также:

compare

public final VectorMask<Double> compare(VectorOperators.Comparison op, double e, VectorMask<Double> m)

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare

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

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

См. также:

blend

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

addIndex

public abstract DoubleVector 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);

Specified by:: addIndex в классе Vector<Double>
Parameters:: scale - число, на которое нужно умножить каждый индекс дорожки N, обычно 1
Returns:: результат приращения каждого элемента дорожки на соответствующий индекс дорожки N, масштабированный на scale

blend

public final DoubleVector blend(double e, VectorMask<Double> m)

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

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

blend

public final DoubleVector blend(long e, VectorMask<Double> m)

Specified by:: blend в классе Vector<Double>
Parameters:: e - скалярный вход, содержащий заменяемое значение дорожки; m - маска, управляющая выбором дорожки скаляра
Returns:: результат смешивания элементов дорожек этого вектора со скалярным значением

slice

public abstract DoubleVector slice(int origin, Vector<Double> v1)

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

Это операция между дорожками, которая сдвигает элементы дорожек вперед из текущего вектора и второго вектора. Оба вектора можно рассматривать как объединенный "фоновый" массив длиной 2*VLENGTH, из которого извлекается срез. Дорожка с номером N в выходном векторе копируется с дорожки origin+N входного вектора, если эта дорожка существует, иначе с дорожки origin+N-VLENGTH второго вектора (который гарантированно существует).

Значение origin должно находиться в диапазоне от 0..VLENGTH. Как граничные случаи, v.slice(0,w) и v.slice(VLENGTH,w) возвращают v и w соответственно.

Parameters:

origin - первая входная дорожка, передаваемая в срез

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

Returns:

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

See Also:

slice

public final DoubleVector slice(int origin, Vector<Double> w, VectorMask<Double> m)

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

Это операция между дорожками, которая сдвигает элементы дорожек вперед из текущего вектора и второго вектора. Оба вектора можно рассматривать как объединенный "фоновый" массив длиной 2*VLENGTH, из которого извлекается срез. Результирующий результат равен выражению broadcast(0).blend(slice(origin,v1),m).

Specified by:

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

Parameters:

origin - первая входная дорожка, передаваемая в срез

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

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

Returns:

See Also:

slice

public abstract DoubleVector slice(int origin)

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


 (origin,

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

Parameters:

origin - первая входная дорожка, передаваемая в срез

Returns:

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

See Also:

unslice

public abstract DoubleVector unslice(int origin, Vector<Double> 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.

Specified by:

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

Parameters:

origin - первая выходная дорожка, принимающая срез

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

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

Returns:

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

See Also:

unslice

public abstract DoubleVector unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m)

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

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

Specified by:

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

Parameters:

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

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

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

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

Returns:

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

See Also:

unslice

public abstract DoubleVector unslice(int origin)

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


 (origin,

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

rearrange

public abstract DoubleVector rearrange(VectorShuffle<Double> m)

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

rearrange

public abstract DoubleVector rearrange(VectorShuffle<Double> s, VectorMask<Double> m)

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

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


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

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

rearrange

public abstract DoubleVector rearrange(VectorShuffle<Double> s, Vector<Double> v)

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

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


 Vector<E> r1 = this.rearrange(s.wrapIndexes());
 // or else: r1 = this.rearrange(s, s.laneIsValid());
 Vector<E> r2 = v.rearrange(s.wrapIndexes());
 return r2.blend(r1,s.laneIsValid());

Specified by:

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

Parameters:

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

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

Returns:

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

See Also:

compress

public abstract DoubleVector compress(VectorMask<Double> m)

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

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

expand

public abstract DoubleVector expand(VectorMask<Double> m)

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

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

selectFrom

public abstract DoubleVector selectFrom(Vector<Double> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

selectFrom

public abstract DoubleVector selectFrom(Vector<Double> s, VectorMask<Double> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

fma

public final DoubleVector fma(Vector<Double> b, Vector<Double> c)

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

Параметры:

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

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

Возвращает:

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

См. также:

fma

public final DoubleVector fma(double b, double c)

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

Параметры:

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

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

Возвращает:

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

См. также:

reduceLanes

public abstract double reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes

public abstract double reduceLanes(VectorOperators.Associative op, VectorMask<Double> m)

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

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

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

lane

public abstract double lane(int i)

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

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

withLane

public abstract DoubleVector withLane(int i, double e)

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

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

toArray

public final double[] toArray()

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

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


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

Specified by:

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

Returns:

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

See Also:

toIntArray

public final int[] toIntArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toLongArray

public final long[] toLongArray()

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


 float

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

Specified by:

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

Returns:

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

See Also:

toDoubleArray

public final double[] toDoubleArray()

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

Specified by:

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

Implementation Note:

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

Returns:

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

See Also:

fromArray

public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset)

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

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

fromArray

public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m)

Загружает вектор из массива типа double[], начиная с смещения и используя маску. Дорожки, где маска не установлена, заполняются значениями по умолчанию double (положительный ноль). Для каждой дорожки вектора, где 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 DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset)

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

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

See Also:

fromArray

public static DoubleVector fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

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

See Also:

fromMemorySegment

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

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

Этот метод ведет себя так, как если бы он возвращал результат вызова fromMemorySegment()^ПРЕВЬЮ следующим образом:


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

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

fromMemorySegment

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

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

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


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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

intoArray

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

Размещает этот вектор в массив типа double[], под управлением маски и с использованием индексов, полученных путём добавления фиксированного 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:

intoMemorySegment

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

Сохраняет этот вектор в сегменте памяти^ПРЕВЬЮ, начиная с определённого смещения и используя явное представление байтового порядка.

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

Этот метод работает так, как будто он вызывает intoMemorySegment()^ПРЕВЬЮ следующим образом:


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

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

intoMemorySegment

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

Сохраняет этот вектор в сегменте памяти^ПРЕВЬЮ, начиная с определённого смещения, используя явное представление байтового порядка и маску.

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

Указано в:

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

public final int hashCode()

Возвращает хэш-код вектора на основе значений регистров и вида вектора.

Указано в:

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

Возвращает:

хэш-код этого вектора

См. также:

species

public final VectorSpecies<Double> 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()

Specified by:

check in class Vector<E>

Type Parameters:

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

Parameters:

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

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Double> maskAll(boolean bit)

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

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

Specified by:

maskAll in class Vector<E>

Parameters:

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

Returns:

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

See Also:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

В качестве примера, преобразование из byte в long (M=8) отбросит 87,5% входных значений, чтобы преобразовать оставшиеся 12,5% в просторные long проходы выходного вектора. Обратное преобразование преобразует все большие результаты, но будет тратить 87,5% проходов в выходном векторе. In-place преобразования (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.
inplace (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:

Преобразование формы

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

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

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

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

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


 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 - номер части результата или ноль, если ни расширения, ни сжатия нет

Возвращает:

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

См. также:

Получить полезную нагрузку

protected final Object getPayload()

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