Класс DoubleVector

java.lang.Object

jdk.incubator.vector.Vector<Double>

jdk.incubator.vector.DoubleVector

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

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<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[], содержащий значения всех элементов вектора, преобразованные к типу double. Длина массива совпадает с длиной вектора. Элементы массива преобразуются так, как если бы они были приведены к типу, и сохраняются в порядке элементов вектора. Эта операция может привести к потере точности, если тип элементов вектора — long.

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

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

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

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

Возвращает:

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

См. также:

fromArray

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

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

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

fromArray

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

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

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

fromArray

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

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

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

Параметры:

species — тип требуемого вектора

a — массив

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

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

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

Возвращает:

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

Вызывает:

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

См. также:

fromArray

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

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

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

Параметры:

species — тип требуемого вектора

a — массив

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

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

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

Возвращает:

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

Вызывает:

См. также:

fromMemorySegment

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

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

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

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

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

fromMemorySegment

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

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

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

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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

Для каждого элемента вектора, где N — индекс элемента вектора, элемент вектора с индексом 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 во втором массиве ints, начиная с заданного mapOffset.

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

Параметры:

a — массив

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

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

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

m — маска

Вызывает:

См. также:

intoMemorySegment

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

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

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

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

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

Определено в:: intoMemorySegment в классе Vector<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 — маска, управляющая выбором элементов
Начиная с:: 19

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

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

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

Возвращает:

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

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

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

equals

public final boolean equals(Object obj)

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

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

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

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

Параметры:

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

Возвращает:

признак идентичности этого вектора другому объекту

См. также:

hashCode

public final int hashCode()

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

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

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Double> species()

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

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

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

check

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

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

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

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

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

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

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

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

Параметры:

species — требуемый вид

Возвращает:

тот же вектор

См. также:

check

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

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

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

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

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Double> maskAll(boolean bit)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Задано в:

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

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

F — тип элемента набора видов в обёртке

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Задано в:

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

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

F — тип элемента выходного набора видов в обёртке

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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

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

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

Задано в:

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

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

F — тип элемента выходного набора видов в обёртке

Параметры:

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

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

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

Возвращает:

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

См. также:

getPayload

protected final Object getPayload()

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