Класс DoubleVector

java.lang.Object

jdk.incubator.vector.Vector<Double>

jdk.incubator.vector.DoubleVector

public abstract class DoubleVector extends Vector<Double>

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

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

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

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

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

`final DoubleVector`	`lanewise(VectorOperators.Binary op, double e)`	Объединяет значения проходов этого вектора со значением вещаемого скаляра.
`final DoubleVector`	`lanewise(VectorOperators.Binary op, double e, VectorMask<Double> m)`	Объединяет значения проходов этого вектора со значением вещаемого скаляра, с выбором элементов прохода, управляемым маской.
`final DoubleVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения проходов этого вектора со значением вещаемого скаляра.
`final DoubleVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Double> m)`	Объединяет соответствующие значения проходов этого вектора со значениями второго входного вектора, с выбором элементов прохода, управляемым маской.
`abstract DoubleVector`	`lanewise(VectorOperators.Binary op, Vector<Double> v)`	Объединяет соответствующие значения проходов этого вектора со значениями второго входного вектора.
`abstract DoubleVector`	`lanewise(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> m)`	Объединяет соответствующие значения проходов этого вектора со значениями второго входного вектора, с выбором элементов прохода, управляемым маской.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, double e1, double e2)`	Объединяет значения проходов этого вектора со значениями двух вещаемых скаляров.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, double e1, double e2, VectorMask<Double> m)`	Объединяет значения проходов этого вектора со значениями двух вещаемых скаляров, с выбором элементов прохода, управляемым маской.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2)`	Объединяет значения проходов этого вектора со значениями другого вектора и вещаемого скаляра.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> m)`	Объединяет значения проходов этого вектора со значениями другого вектора и вещаемого скаляра, с выбором элементов прохода, управляемым маской.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2)`	Объединяет значения проходов этого вектора со значениями другого вектора и вещаемого скаляра.
`final DoubleVector`	`lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> m)`	Объединяет значения проходов этого вектора со значениями другого вектора и вещаемого скаляра, с выбором элементов прохода, управляемым маской.
`abstract DoubleVector`	`lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2)`	Объединяет соответствующие значения проходов этого вектора с проходами второго и третьего входных векторов.
`abstract DoubleVector`	`lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> m)`	Объединяет соответствующие значения проходов этого вектора с проходами второго и третьего входных векторов, с выбором элементов прохода, управляемым маской.
`abstract DoubleVector`	`lanewise(VectorOperators.Unary op)`	Операции над значениями проходов этого вектора.
`abstract DoubleVector`	`lanewise(VectorOperators.Unary op, VectorMask<Double> m)`	Операции над значениями проходов этого вектора, с выбором элементов прохода, управляемым маской.
`final VectorMask<Double>`	`lt(double e)`	Проверка, меньше ли этот вектор входного скаляра.
`final VectorMask<Double>`	`lt(Vector<Double> v)`	Проверка, меньше ли этот вектор другого входного вектора.
`final VectorMask<Double>`	`maskAll(boolean bit)`	Возвращает маску того же вида, что и этот вектор, где каждый проход установлен или сброшен в соответствии с заданным одиночным булевым значением, которое транслируется во все проходы.
`final DoubleVector`	`max(double e)`	Вычисление большего из этого вектора и трансляции входного скаляра.
`final DoubleVector`	`max(Vector<Double> v)`	Вычисление большего из этого вектора и второго входного вектора.
`final DoubleVector`	`min(double e)`	Вычисление меньшего из этого вектора и трансляции входного скаляра.
`final DoubleVector`	`min(Vector<Double> v)`	Вычисление меньшего из этого вектора и второго входного вектора.
`final DoubleVector`	`mul(double e)`	Умножение этого вектора на трансляцию входного скаляра.
`final DoubleVector`	`mul(double e, VectorMask<Double> m)`	Умножение этого вектора на трансляцию входного скаляра, выбирая элементы прохода, управляемые маской.
`final DoubleVector`	`mul(Vector<Double> v)`	Умножение этого вектора на второй входной вектор.
`final DoubleVector`	`mul(Vector<Double> v, VectorMask<Double> m)`	Умножение этого вектора на второй входной вектор под управлением маски.
`final DoubleVector`	`neg()`	Изменение знака этого вектора.
`final DoubleVector`	`pow(double b)`	Возведение этого вектора в степень скаляра.
`final DoubleVector`	`pow(Vector<Double> b)`	Возведение этого вектора в степень второго входного вектора.
`abstract DoubleVector`	`rearrange(VectorShuffle<Double> shuffle)`	Переупорядочивание элементов прохода этого вектора, выбирая проходы под управлением определённого перемешивания.
`abstract DoubleVector`	`rearrange(VectorShuffle<Double> s, Vector<Double> v)`	Переупорядочивание элементов прохода двух векторов, выбирая проходы под управлением определённого перемешивания, используя как обычные, так и исключительные индексы в перемешивании для управления данными.
`abstract DoubleVector`	`rearrange(VectorShuffle<Double> s, VectorMask<Double> m)`	Переупорядочивание элементов прохода этого вектора, выбирая проходы под управлением определённого перемешивания и маски.
`abstract double`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное по всем проходам этого вектора.
`abstract double`	`reduceLanes(VectorOperators.Associative op, VectorMask<Double> m)`	Возвращает значение, накопленное по выбранным проходам этого вектора, управляемым маской.
`final ByteVector`	`reinterpretAsBytes()`	Представление этого вектора как вектора той же формы и содержимого, но с типом прохода `byte`, где байты извлекаются из проходов в соответствии с порядком little-endian.
`DoubleVector`	`reinterpretAsDoubles()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом прохода `double`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`FloatVector`	`reinterpretAsFloats()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом прохода `float`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`IntVector`	`reinterpretAsInts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом прохода `int`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`LongVector`	`reinterpretAsLongs()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом прохода `long`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`ShortVector`	`reinterpretAsShorts()`	Переинтерпретирует этот вектор как вектор той же формы и содержимого, но с типом прохода `short`, где проходы собираются из последовательных байтов в соответствии с порядком little-endian.
`abstract DoubleVector`	`selectFrom(Vector<Double> v)`	Используя значения индексов, хранящихся в проходах этого вектора, собирает значения, хранящиеся во втором векторе `v`.
`abstract DoubleVector`	`selectFrom(Vector<Double> 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()`	Возвращает строковое представление этого вектора, имеющее вид `"[0,1,2...]"`, отображающее значения элементов вектора в порядке следования элементов.
`abstract DoubleVector`	`unslice(int origin)`	Инвертирует срез slice(), вставляя текущий вектор в качестве среза в «фоновый» вход с нулевыми значениями элементов.
`abstract DoubleVector`	`unslice(int origin, Vector<Double> w, int part)`	Инвертирует срез slice(), вставляя текущий вектор в качестве среза в другой «фоновый» входной вектор, который рассматривается как один из входов гипотетической последующей операции `slice()`.
`abstract DoubleVector`	`unslice(int origin, Vector<Double> w, int part, VectorMask<Double> m)`	Инвертирует срез slice(), вставляя (под управлением маски) текущий вектор в качестве среза в другой «фоновый» входной вектор, который рассматривается как один из входов гипотетической последующей операции `slice()`.
`final DoubleVector`	`viewAsFloatingLanes()`	Представляет этот вектор как вектор с той же формой, длиной и содержимым, но типом элемента, являющимся плавающей точкой.
`final LongVector`	`viewAsIntegralLanes()`	Представляет этот вектор как вектор с той же формой, длиной и содержимым, но типом элемента, не являющимся плавающей точкой.
`abstract DoubleVector`	`withLane(int i, double e)`	Заменяет элемент в этом векторе по индексу элемента `i` значением `e`.
`static DoubleVector`	`zero(VectorSpecies<Double> species)`	Возвращает вектор заданного вида, где все элементы установлены в ноль, значение по умолчанию для примитивного типа.

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

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

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

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

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

SPECIES_64

public static final VectorSpecies<Double> SPECIES_64

Species representing DoubleVectors of VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Double> SPECIES_128

Species representing DoubleVectors of VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Double> SPECIES_256

Species representing DoubleVectors of VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Double> SPECIES_512

Species representing DoubleVectors of VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Double> SPECIES_MAX

Species representing DoubleVectors of VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Double> SPECIES_PREFERRED

Preferred species for DoubleVectors. A preferred species is a species of maximal bit-size for the platform.

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

zero

public static DoubleVector zero(VectorSpecies<Double> species)

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

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

broadcast

public abstract DoubleVector broadcast(double e)

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

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

API Note:

В отличие от аналогичного метода с именем 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 Note:

При работе с подтипами векторов, такими как 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:

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

Параметры:

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключения:

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

См. также:

fromArray

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

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

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

Параметры:

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

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

Параметры:

a - массив

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

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

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

Исключения:

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

См. также:

intoArray

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

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

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

Параметры:

a - массив

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

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

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

m - маска

Исключения:

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

См. также:

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, где байты извлекаются из разрядов в соответствии с порядком little-endian. Это удобный метод для выражения reinterpretShape(species().withLanes(byte.class)). Его можно рассматривать как обратное действие различным методам, которые объединяют байты в большие разряды в одном векторе, таким как Vector.reinterpretAsInts().

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

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

Возвращает:

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

См. также:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

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

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

Возвращает:

оригинальный вектор, переинтерпретированный как вектор без плавающей запятой

См. также:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

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

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

Возвращает:

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

См. также:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

hashCode

public final int hashCode()

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

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

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

Возвращает:

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

См. также:

species

public final VectorSpecies<Double> species()

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

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

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

check

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

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

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

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

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

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

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

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

Параметры:

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

Возвращает:

тот же вектор

См. также:

check

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

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

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

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

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, где элементы собираются из последовательных байтов в порядке little-endian. Это удобный метод для выражения reinterpretShape(species().withLanes(short.class)). Можно рассматривать как обратное преобразование к Vector.reinterpretAsBytes().

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

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

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

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

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

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

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

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

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

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

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

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

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

Определено:

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

Возвращает:

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

См. также:

END_OF_DOCUMENT_MARKER

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

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

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

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

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

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


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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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

protected final Object getPayload()

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