Класс DoubleVector

java.lang.Object

jdk.incubator.vector.Vector<Double>

jdk.incubator.vector.DoubleVector

public abstract class DoubleVector extends Vector<Double>

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

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

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

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

Модификатор и тип	Метод	Описание
`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 ms, long offset, ByteOrder bo)`	Загружает вектор из сегмента памяти, начиная со смещения в сегменте памяти.
`static DoubleVector`	`fromMemorySegment(VectorSpecies<Double> species, MemorySegment 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 ms, long offset, ByteOrder bo)`	Сохраняет этот вектор в сегмент памяти, начиная с заданного смещения и используя явно заданный порядок байтов.
`final void`	`intoMemorySegment(MemorySegment 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> shuffle)`	Переставляет элементы полос этого вектора, выбирая полосы под управлением заданной перестановки.
`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`, извлекая байты из полос в порядке от младшего к старшему.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `double`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `float`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `int`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `long`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и с тем же содержимым, но с типом полос `short`; полосы формируются из последовательных байтов в порядке от младшего к старшему.
`abstract DoubleVector`	`selectFrom(Vector<Double> v)`	Используя значения индексов, хранящиеся в полосах этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`abstract DoubleVector`	`selectFrom(Vector<Double> v1, Vector<Double> v2)`	Используя значения, хранящиеся в полосах этого вектора, собирает значения, хранящиеся во втором векторе `v1` и третьем векторе `v2`.
`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()`	Возвращает массив `long[]`, содержащий значения всех полос, преобразованные к типу `long`.
`final String`	`toString()`	Возвращает строковое представление этого вектора в форме `"[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)`	Возвращает вектор заданного вида, во всех полосах которого установлено нулевое значение — значение примитивного типа по умолчанию.

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

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

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

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

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

SPECIES_64

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

public final DoubleVector sub(Vector<Double> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

sub

public final DoubleVector sub(double e)

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

Параметры:

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

Возвращает:

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

См. также:

sub

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

sub

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

public final DoubleVector mul(Vector<Double> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

mul

public final DoubleVector mul(double e)

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

Параметры:

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

Возвращает:

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

См. также:

mul

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

mul

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

public final DoubleVector div(Vector<Double> v)

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

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

div

public final DoubleVector div(double e)

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

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

Параметры:

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

Возвращает:

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

См. также:

div

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

div

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

max

public final DoubleVector max(double e)

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

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

Параметры:

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

Возвращает:

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

См. также:

pow

public final DoubleVector pow(Vector<Double> b)

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

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

Параметры:

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

Возвращает:

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

См. также:

pow

public final DoubleVector pow(double b)

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

Параметры:

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

Возвращает:

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

См. также:

neg

public final DoubleVector neg()

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

Переопределено:

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

Возвращает:

вектор, противоположный этому вектору

См. также:

abs

public final DoubleVector abs()

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

Переопределено:

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

Возвращает:

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

См. также:

sqrt

public final DoubleVector sqrt()

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

Возвращает:

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

См. также:

eq

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

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

Переопределено:

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Double> eq(double e)

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

Параметры:

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

Возвращает:

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

См. также:

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

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

blend

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

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

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

blend

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

Переопределено:: blend в классе Vector<Double>
Параметры:: e — входной скаляр, содержащий значение для замены элемента; m — маска, определяющая выбор скалярного значения
Возвращает:: результат объединения элементов этого вектора со скалярным значением

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.

Параметры:

origin — первый входной элемент, переносимый в срез

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

Возвращает:

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

См. также:

slice

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

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

Переопределено:

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

Параметры:

origin — первый входной элемент, переносимый в срез

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

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

Возвращает:

См. также:

slice

public abstract DoubleVector slice(int origin)

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


(origin,

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

Параметры:

origin — первый входной элемент, переносимый в срез

Возвращает:

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

См. также:

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.

Переопределено:

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

Параметры:

origin — первый выходной элемент, в который помещается срез

w — фоновый вектор, который (в виде двух копий) будет принимать вставленный срез

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

Возвращает:

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

См. также:

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

Определён в:

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

unslice

public abstract DoubleVector unslice(int origin)

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


(origin,

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

public abstract DoubleVector rearrange(VectorShuffle<Double> shuffle)

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

Определён в:

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

Параметры:

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

Возвращает:

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

См. также:

rearrange

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

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

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compress

public abstract DoubleVector compress(VectorMask<Double> m)

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

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

expand

public abstract DoubleVector expand(VectorMask<Double> m)

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

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

selectFrom

public abstract DoubleVector selectFrom(Vector<Double> v)

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

См. также:

selectFrom

public abstract DoubleVector selectFrom(Vector<Double> v1, Vector<Double> v2)

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

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

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

Определён в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

withLane

public abstract DoubleVector withLane(int i, double e)

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

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

toArray

public final double[] toArray()

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

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

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

Определён в:

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


float

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

Определён в:

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

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


float

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

Определён в:

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

Указано в:

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

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

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

Возвращает:

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

См. также:

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

species — тип вектора

a — массив

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

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

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

Возвращает:

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

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

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

См. также:

fromArray

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

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

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

Параметры:

species — тип вектора

a — массив

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

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

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

Возвращает:

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

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

См. также:

fromMemorySegment

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

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

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

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

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

fromMemorySegment

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

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

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

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

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

intoArray

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

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

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

Параметры:: a — массив типа double[]; offset — смещение в массиве
Выбрасывает:: IndexOutOfBoundsException — если offset+N < 0 или offset+N >= a.length для любой lane N в векторе

intoArray

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

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

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

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

Параметры:: a — массив типа double[]; offset — смещение в массиве; m — маска, управляющая сохранением lane
Выбрасывает:: IndexOutOfBoundsException — если offset+N < 0 или offset+N >= a.length для любой lane N вектора, для которой установлена маска

intoArray

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

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

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

Параметры:

a — массив

offset — смещение, которое нужно объединить со смещениями карты индексов

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

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

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

См. также:

intoArray

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

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

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

Параметры:

a — массив

offset — смещение, которое нужно объединить со смещениями карты индексов

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

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

m — маска

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

См. также:

intoMemorySegment

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

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

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

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

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

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

intoMemorySegment

public final void intoMemorySegment(MemorySegment 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 — маска, управляющая выбором lane
Начиная с:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

Указано в:

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

Представляет этот вектор как вектор той же формы, длины и с тем же содержимым, но с типом lane, являющимся типом с плавающей точкой. Это переинтерпретирующее приведение значений lane выполняется поэлементно. Поэтому этот метод не изменяет VSHAPE или VLENGTH, а побитовое содержимое вектора остаётся прежним. Если ETYPE вектора уже является типом с плавающей точкой, возвращается тот же вектор без изменений. Если размер элемента вектора не соответствует размеру ни одного типа с плавающей точкой, выбрасывается 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...]", содержащее значения lane вектора в порядке lane. Строка формируется так, как если бы был вызван метод Arrays.toString(), соответствующий массиву типа double, возвращённому методом this.toArray().

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

equals

public final boolean equals(Object obj)

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

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

Указано в:

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

Параметры:

obj — объект-ссылка, с которым выполняется сравнение.

Возвращает:

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

См. также:

hashCode

public final int hashCode()

Возвращает хеш-код вектора, основанный на значениях lane и species вектора.

Указано в:

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Double> species()

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

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

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

check

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

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

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

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

Указано в:

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

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

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

Параметры:

species — требуемый species

Возвращает:

тот же вектор

См. также:

check

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

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

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

Указано в:

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Double> maskAll(boolean bit)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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