Класс DoubleVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

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

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.DoubleVector

public abstract class DoubleVector extends Vector<E>

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

END_OF_DOCUMENT_MARKER

`final DoubleVector`	`sub(Vector<Double> v)`	Вычитает второй входной вектор из этого вектора.
`final DoubleVector`	`sub(Vector<Double> v, VectorMask<Double> m)`	Вычитает второй входной вектор из этого вектора под управлением маски.
`abstract VectorMask<Double>`	`test(VectorOperators.Test op)`	Проверяет элементы вектора в соответствии с заданной операцией.
`final VectorMask<Double>`	`test(VectorOperators.Test op, VectorMask<Double> m)`	Проверяет выбранные элементы вектора в соответствии с заданной операцией.
`final double[]`	`test(VectorOperators.Test op, VectorMask<Double> m)`	Возвращает массив типа `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, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle

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

getPayload

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

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

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

SPECIES_64

public static final VectorSpecies<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 final DoubleVector lanewise(VectorOperators.Unary op, VectorMask<Double> m)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

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

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

Параметры:

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

v - вторая входная векторная переменная

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,double,VectorMask)

lanewise

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

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

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

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

lanewise

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

Объединяет значения элементов данной векторной переменной со значением транслируемого скаляра. Это операция по элементам, которая применяет выбранную операцию к каждому элементу. Возвращаемое значение будет равно этому выражению: this.lanewise(op, this.broadcast(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(VectorOperators.Ternary,double,double,VectorMask)
lanewise(VectorOperators.Ternary,Vector,double,VectorMask)
lanewise(VectorOperators.Ternary,double,Vector,VectorMask)
lanewise(VectorOperators.Ternary,double,double)
lanewise(VectorOperators.Ternary,Vector,double)
lanewise(VectorOperators.Ternary,double,Vector)

lanewise

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

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

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

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

Параметры:

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

v1 - вторая входная векторная переменная

v2 - третья входная векторная переменная

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

Возвращает:

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

См. также:

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

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

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

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

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

lanewise

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

Параметры:

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

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

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

Возвращает:

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

Изначает исключение:

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

См. также:

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

lanewise

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

Параметры:

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

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

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

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

Возвращает:

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

Изначает исключение:

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

См. также:

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

add

public final DoubleVector add(Vector<Double> v)

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

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

Задано:

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

Параметры:

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

Возвращает:

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

См. также:

add(double)

add

public final DoubleVector add(double e)

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

Параметры:

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

Возвращает:

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

См. также:

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

add

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

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

Задано:

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

Параметры:

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

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

Возвращает:

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

См. также:

add(double,VectorMask)

add

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

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

Parameters:

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

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

Returns:

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

See Also:

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

sub

public final DoubleVector sub(Vector<Double> v)

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

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

Specified by:

sub in class Vector<Double>

Parameters:

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

Returns:

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

See Also:

sub(double)

sub

public final DoubleVector sub(double e)

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

Parameters:

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

Returns:

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

See Also:

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

sub

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

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

Specified by:

sub in class Vector<Double>

Parameters:

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

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

Returns:

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

See Also:

sub(double,VectorMask)

sub

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

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

Parameters:

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

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

Returns:

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

See Also:

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

mul

public final DoubleVector mul(Vector<Double> v)

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

Specified by:

mul in class Vector<Double>

Parameters:

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

Returns:

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

See Also:

mul(double)

mul

public final DoubleVector mul(double e)

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

Parameters:

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

Returns:

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

See Also:

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

mul

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

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

Specified by:

mul in class Vector<Double>

Parameters:

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

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

Returns:

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

See Also:

mul(double,VectorMask)

END_OF_DOCUMENT_MARKER

mul

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

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

Parameters:

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

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

Returns:

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

See Also:

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

div

public final DoubleVector div(Vector<Double> v)

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

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

Specified by:

div in class Vector<Double>

API Note:

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

Parameters:

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

Returns:

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

See Also:

div

public final DoubleVector div(double e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

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

div

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

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

Specified by:

div in class Vector<Double>

API Note:

Parameters:

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

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

Returns:

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

See Also:

div(double,VectorMask)

div

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

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

API Note:

Parameters:

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

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

Returns:

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

See Also:

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

min

public final DoubleVector min(Vector<Double> v)

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

Specified by:

min in class Vector<Double>

API Note:

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

Parameters:

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

Returns:

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

See Also:

min

public final DoubleVector min(double e)

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

API Note:

Parameters:

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

Returns:

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

See Also:

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

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 - входной скаляр

Возвращает:

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

См. также:

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

pow

public final DoubleVector pow(Vector<Double> b)

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

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

Параметры:

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

Возвращает:

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

См. также:

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

pow

public final DoubleVector pow(double b)

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

Параметры:

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

Возвращает:

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

См. также:

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

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

Возвращает:

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

См. также:

VectorOperators.SQRT
lanewise(VectorOperators.Unary,VectorMask)

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

См. также:

compare(VectorOperators.Comparison,double)

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 - входной скаляр

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,double)

test

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.test(VectorOperators.Test)

compare

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

Указано в:

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

Параметры:

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

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

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

Возвращает:

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

См. также:

Vector.compare(VectorOperators.Comparison, Vector)

compare

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

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

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

Параметры:

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

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

Возвращает:

См. также:

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

compare

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

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

Параметры:

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

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

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

Возвращает:

См. также:

compare(VectorOperators.Comparison,Vector,VectorMask)

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.

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

Указано в:

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

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

Определено:

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

Параметры:

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

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

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

См. также:

rearrange

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

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

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


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

Определено:

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

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

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

См. также:

selectFrom

public abstract DoubleVector selectFrom(Vector<Double> v)

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

Vector.rearrange(VectorShuffle)

selectFrom

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

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

fma

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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 - скалярное слагаемое

Возвращает:

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

См. также:

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

reduceLanes

public abstract double reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

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

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

См. также:

reduceLanes(VectorOperators.Associative)

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

См. также:

fromByteArray

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

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

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


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

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

fromByteArray

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

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

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


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

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

fromArray

public static 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]].

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

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

See Also:

toIntArray()

fromArray

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

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

See Also:

toIntArray()

fromByteBuffer

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

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

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


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

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

fromByteBuffer

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

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

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


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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

toIntArray()

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

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

See Also:

toIntArray()

intoByteArray

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

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

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

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


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

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

intoByteArray

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

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

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


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

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

intoByteBuffer

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

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

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


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

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

intoByteBuffer

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

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

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


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

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


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

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

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final LongVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final DoubleVector viewAsFloatingLanes()

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

Specified by:

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

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

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

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

значение хэш-кода для этого вектора

See Also:

species

public final VectorSpecies<Double> species()

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

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

Specified by:: species в классе Vector<E>
Returns:: вид этого вектора

check

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

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

Returns:

тот же вектор

See Also:

check

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

elementType - требуемый тип полосы

Returns:

тот же вектор

See Also:

maskAll

public final VectorMask<Double> maskAll(boolean bit)

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

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

Specified by:

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

Parameters:

bit - заданный бит маски для дублирования

Returns:

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

See Also:

VectorSpecies.maskAll(boolean)

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

Specified by:: reinterpretAsShorts в классе Vector<E>
Returns:: ShortVector с той же формой и содержанием информации

reinterpretAsInts

public IntVector reinterpretAsInts()

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

Specified by:: reinterpretAsInts в классе Vector<E>
Returns:: IntVector с той же формой и содержанием информации

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

Specified by:: reinterpretAsLongs в классе Vector<E>
Returns:: LongVector с той же формой и содержанием информации

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

Specified by:: reinterpretAsFloats в классе Vector<E>
Returns:: FloatVector с той же формой и содержанием информации

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

Specified by:: reinterpretAsDoubles в классе Vector<E>
Returns:: DoubleVector с той же формой и содержанием информации

convert

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

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

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

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

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

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

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

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

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

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

castShape

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

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

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

Указано в:

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

convertShape

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

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

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

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

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


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

Задано:

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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