Класс ShortVector

java.lang.Object

jdk.internal.vm.vector.VectorSupport.VectorPayload

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

jdk.incubator.vector.Vector<E>

jdk.incubator.vector.ShortVector

public abstract class ShortVector extends Vector<E>

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

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

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

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

Модификатор и тип	Метод	Описание
`final ShortVector`	`abs()`	Возвращает абсолютное значение этого вектора.
`final ShortVector`	`add(short e)`	Добавляет этот вектор к рассылкам входного скаляра.
`final ShortVector`	`add(short e, VectorMask<Short> m)`	Добавляет этот вектор к рассылке входного скаляра, выбирая элементы канала, управляемые маской.
`final ShortVector`	`add(Vector<Short> v)`	Добавляет этот вектор ко второму входному вектору.
`final ShortVector`	`add(Vector<Short> v, VectorMask<Short> m)`	Добавляет этот вектор ко второму входному вектору, выбирая каналы под управлением маски.
`abstract ShortVector`	`addIndex(int scale)`	Добавляет каналы этого вектора к их соответствующим номерам канала, масштабированным заданным константом.
`final ShortVector`	`and(short e)`	Вычисляет битовую логическую конъюнкцию (`&`) этого вектора и скаляра.
`final ShortVector`	`and(Vector<Short> v)`	Вычисляет битовую логическую конъюнкцию (`&`) этого вектора и второго входного вектора.
`final ShortVector`	`bitwiseBlend(short bits, short mask)`	Объединяет биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски.
`final ShortVector`	`bitwiseBlend(short bits, Vector<Short> mask)`	Объединяет биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски.
`final ShortVector`	`bitwiseBlend(Vector<Short> bits, short mask)`	Объединяет биты двух векторов под управлением скаляра, который предоставляет биты маски.
`final ShortVector`	`bitwiseBlend(Vector<Short> bits, Vector<Short> mask)`	Объединяет биты двух векторов под управлением третьего, который предоставляет биты маски.
`final ShortVector`	`blend(long e, VectorMask<Short> m)`	Заменяет выбранные каналы этого вектора значением скаляра под управлением маски.
`final ShortVector`	`blend(short e, VectorMask<Short> m)`	Заменяет выбранные каналы этого вектора значением скаляра под управлением маски.
`abstract ShortVector`	`blend(Vector<Short> v, VectorMask<Short> m)`	Заменяет выбранные каналы этого вектора соответствующими каналами из второго входного вектора под управлением маски.
`abstract ShortVector`	`broadcast(long e)`	Возвращает вектор того же вида, что и этот, где все элементы канала установлены в примитивное значение `e`.
`abstract ShortVector`	`broadcast(short e)`	Возвращает вектор того же вида, что и этот, где все элементы канала установлены в примитивное значение `e`.
`static ShortVector`	`broadcast(VectorSpecies<Short> species, long e)`	Возвращает вектор заданного вида, где все элементы канала установлены в примитивное значение `e`.
`static ShortVector`	`broadcast(VectorSpecies<Short> species, short 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<Short>`	`compare(VectorOperators.Comparison op, long e)`	Тестирует этот вектор путем сравнения его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Short>`	`compare(VectorOperators.Comparison op, long e, VectorMask<Short> m)`	Тестирует этот вектор путем сравнения его со входным скаляром в соответствии с заданной операцией сравнения в каналах, выбранных маской.
`abstract VectorMask<Short>`	`compare(VectorOperators.Comparison op, short e)`	Тестирует этот вектор путем сравнения его со входным скаляром в соответствии с заданной операцией сравнения.
`final VectorMask<Short>`	`compare(VectorOperators.Comparison op, short e, VectorMask<Short> m)`	Тестирует этот вектор путем сравнения его со входным скаляром в соответствии с заданной операцией сравнения в каналах, выбранных маской.
`abstract VectorMask<Short>`	`compare(VectorOperators.Comparison op, Vector<Short> v)`	Тестирует этот вектор путем сравнения его с другим входным вектором в соответствии с заданной операцией сравнения.
`final VectorMask<Short>`	`compare(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m)`	Тестирует этот вектор путем сравнения его с другим входным вектором в соответствии с заданной операцией сравнения в каналах, выбранных маской.
`final <F> Vector<F>`	`convert(VectorOperators.Conversion<Short,F> conv, int part)`	Преобразует этот вектор в вектор той же формы и нового типа элемента, преобразуя значения канала из текущего `ETYPE` в новый тип канала (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`abstract <F> Vector<F>`	`convertShape(VectorOperators.Conversion<Short,F> conv, VectorSpecies<F> rsp, int part)`	Преобразует этот вектор в вектор заданного вида, формы и типа элемента, преобразуя значения канала из текущего `ETYPE` в новый тип канала (называемый `FTYPE` здесь) в соответствии с указанным преобразованием.
`final ShortVector`	`div(short e)`	Делит этот вектор на рассылку входного скаляра.
`final ShortVector`	`div(short e, VectorMask<Short> m)`	Делит этот вектор на рассылку входного скаляра, выбирая элементы канала, управляемые маской.
`final ShortVector`	`div(Vector<Short> v)`	Делит этот вектор на второй входной вектор.
`final ShortVector`	`div(Vector<Short> v, VectorMask<Short> m)`	Делит этот вектор на второй входной вектор под управлением маски.
`final VectorMask<Short>`	`eq(short e)`	Проверяет, равен ли этот вектор входному скаляру.
`final VectorMask<Short>`	`eq(Vector<Short> v)`	Проверяет, равен ли этот вектор другому входному вектору.
`final boolean`	`equals(Object obj)`	Указывает, идентичен ли этот вектор какому-либо другому объекту.
`static ShortVector`	`fromArray(VectorSpecies<Short> species, short[] a, int offset)`	Загружает вектор из массива типа `short[]`, начиная со смещения.
`static ShortVector`	`fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, состоящий из элементов из массива типа `short[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static ShortVector`	`fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`	Собрать новый вектор, состоящий из элементов из массива типа `short[]`, под управлением маски и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static ShortVector`	`fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)`	Загружает вектор из массива типа `short[]`, начиная со смещения и используя маску.
`static ShortVector`	`fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, ByteOrder bo)`	Загружает вектор из массива байтов, начиная со смещения.
`static ShortVector`	`fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, ByteOrder bo, VectorMask<Short> m)`	Загружает вектор из массива байтов, начиная со смещения и используя маску.
`static ShortVector`	`fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, ByteOrder bo)`	Загружает вектор из буфера байтов, начиная со смещения в буфере байтов.
`static ShortVector`	`fromByteBuffer(VectorSpecies<Short> species, ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m)`	Загружает вектор из буфера байтов, начиная со смещения в буфере байтов и используя маску.
`static ShortVector`	`fromCharArray(VectorSpecies<Short> species, char[] a, int offset)`	Загружает вектор из массива типа `char[]`, начиная со смещения.
`static ShortVector`	`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset)`	Собрать новый вектор, состоящий из элементов из массива типа `char[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static ShortVector`	`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`	Собрать новый вектор, состоящий из элементов из массива типа `char[]`, под управлением маски и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`static ShortVector`	`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)`	Загружает вектор из массива типа `char[]`, начиная со смещения и используя маску.

`final int`	`hashCode()`	Возвращает значение хэша для вектора.
`final void`	`intoArray(short[] a, int offset)`	Сохраняет этот вектор в массив типа `short[]` начиная со смещения.
`final void`	`intoArray(short[] a, int offset, int[] indexMap, int mapOffset)`	Рассыпывает этот вектор в массив типа `short[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`	Рассыпывает этот вектор в массив типа `short[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoArray(short[] a, int offset, VectorMask<Short> m)`	Сохраняет этот вектор в массив типа `short[]` начиная со смещения и используя маску.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo)`	Сохраняет этот вектор в массив байт начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteArray(byte[] a, int offset, ByteOrder bo, VectorMask<Short> m)`	Сохраняет этот вектор в массив байт начиная со смещения, используя явное порядок байтов и маску.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo)`	Сохраняет этот вектор в буфер байтов начиная со смещения, используя явное порядок байтов.
`final void`	`intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> m)`	Сохраняет этот вектор в буфер байтов начиная со смещения, используя явное порядок байтов и маску.
`final void`	`intoCharArray(char[] a, int offset)`	Сохраняет этот вектор в массив типа `char[]` начиная со смещения.
`final void`	`intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset)`	Рассыпывает этот вектор в массив типа `char[]`, используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`	Рассыпывает этот вектор в массив типа `char[]`, под управлением маски, и используя индексы, полученные путем добавления фиксированного `offset` к ряду вторичных смещений из карты индексов.
`final void`	`intoCharArray(char[] a, int offset, VectorMask<Short> m)`	Сохраняет этот вектор в массив типа `char[]` начиная со смещения и используя маску.
`abstract short`	`lane(int i)`	Возвращает элемент канала по индексу канала `i`
`final ShortVector`	`lanewise(VectorOperators.Binary op, long e)`	Объединяет значения каналов этого вектора со значением широковещательного скаляра.
`final ShortVector`	`lanewise(VectorOperators.Binary op, long e, VectorMask<Short> m)`	Объединяет соответствующие значения каналов этого вектора со значениями второго входного вектора, с выбором элементов канала, контролируемым маской.
`final ShortVector`	`lanewise(VectorOperators.Binary op, short e)`	Объединяет значения каналов этого вектора со значением широковещательного скаляра.
`final ShortVector`	`lanewise(VectorOperators.Binary op, short e, VectorMask<Short> m)`	Объединяет значения каналов этого вектора со значением широковещательного скаляра, с выбором элементов канала, контролируемым маской.
`abstract ShortVector`	`lanewise(VectorOperators.Binary op, Vector<Short> v)`	Объединяет соответствующие значения каналов этого вектора со значениями второго входного вектора.
`final ShortVector`	`lanewise(VectorOperators.Binary op, Vector<Short> v, VectorMask<Short> m)`	Объединяет соответствующие значения каналов этого вектора со значениями второго входного вектора, с выбором элементов канала, контролируемым маской.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, short e1, short e2)`	Объединяет значения каналов этого вектора со значениями двух широковещательных скаляров.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, short e1, short e2, VectorMask<Short> m)`	Объединяет значения каналов этого вектора со значениями двух широковещательных скаляров, с выбором элементов канала, контролируемым маской.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2)`	Объединяет значения каналов этого вектора со значениями другого вектора и широковещательного скаляра.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2, VectorMask<Short> m)`	Объединяет значения каналов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов канала, контролируемым маской.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2)`	Объединяет значения каналов этого вектора со значениями другого вектора и широковещательного скаляра.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2, VectorMask<Short> m)`	Объединяет значения каналов этого вектора со значениями другого вектора и широковещательного скаляра, с выбором элементов канала, контролируемым маской.
`abstract ShortVector`	`lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2)`	Объединяет соответствующие значения каналов этого вектора с каналами второго и третьего входных векторов.
`final ShortVector`	`lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2, VectorMask<Short> m)`	Объединяет соответствующие значения каналов этого вектора с каналами второго и третьего входных векторов, с выбором элементов канала, контролируемым маской.
`abstract ShortVector`	`lanewise(VectorOperators.Unary op)`	Осуществляет операцию над значениями каналов этого вектора.
`final ShortVector`	`lanewise(VectorOperators.Unary op, VectorMask<Short> m)`	Осуществляет операцию над значениями каналов этого вектора, с выбором элементов канала, контролируемым маской.
`final VectorMask<Short>`	`lt(short e)`	Проверяет, меньше ли этот вектор входного скаляра.
`final VectorMask<Short>`	`lt(Vector<Short> v)`	Проверяет, меньше ли этот вектор другого входного вектора.
`final VectorMask<Short>`	`maskAll(boolean bit)`	Возвращает маску того же типа, что и этот вектор, где каждый канал установлен или сброшен в соответствии с заданным одиночным булевым значением, которое широковещательно передается во все каналы.
`final ShortVector`	`max(short e)`	Вычисляет большее значение между этим вектором и широковещательным входным скаляром.
`final ShortVector`	`max(Vector<Short> v)`	Вычисляет большее значение между этим вектором и вторым входным вектором.
`final ShortVector`	`min(short e)`	Вычисляет меньшее значение между этим вектором и широковещательным входным скаляром.
`final ShortVector`	`min(Vector<Short> v)`	Вычисляет меньшее значение между этим вектором и вторым входным вектором.
`final ShortVector`	`mul(short e)`	Умножает этот вектор на широковещательный входной скаляр.
`final ShortVector`	`mul(short e, VectorMask<Short> m)`	Умножает этот вектор на широковещательный входной скаляр, выбирая элементы канала, контролируемые маской.
`final ShortVector`	`mul(Vector<Short> v)`	Умножает этот вектор на второй входной вектор.
`final ShortVector`	`mul(Vector<Short> v, VectorMask<Short> m)`	Умножает этот вектор на второй входной вектор под управлением маски.
`final ShortVector`	`neg()`	Изменяет знак этого вектора.
`final ShortVector`	`not()`	Вычисляет побитовое логическое отрицание (`~`) этого вектора.
`final ShortVector`	`or(short e)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и скаляра.
`final ShortVector`	`or(Vector<Short> v)`	Вычисляет побитовое логическое дизъюнкцию (`\|`) этого вектора и второго входного вектора.
`abstract ShortVector`	`rearrange(VectorShuffle<Short> m)`	Переупорядочивает элементы канала этого вектора, выбирая каналы под управлением определенной перестановки.
`abstract ShortVector`	`rearrange(VectorShuffle<Short> s, Vector<Short> v)`	Переупорядочивает элементы каналов двух векторов, выбирая каналы под управлением определенной перестановки, используя как нормальные, так и исключительные индексы в перестановке для управления данными.
`abstract ShortVector`	`rearrange(VectorShuffle<Short> s, VectorMask<Short> m)`	Переупорядочивает элементы канала этого вектора, выбирая каналы под управлением определенной перестановки и маски.
`abstract short`	`reduceLanes(VectorOperators.Associative op)`	Возвращает значение, накопленное из всех каналов этого вектора.
`abstract short`	`reduceLanes(VectorOperators.Associative op, VectorMask<Short> m)`	Возвращает значение, накопленное из выбранных каналов этого вектора, контролируемых маской.
`final ByteVector`	`reinterpretAsBytes()`	Представляет этот вектор как вектор той же формы и содержимого, но типа канала `byte`, где байты извлекаются из каналов в соответствии с порядком little-endian.

END_OF_DOCUMENT_MARKER

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

Вид, представляющий ShortVector с VectorShape.S_64_BIT.

SPECIES_128

public static final VectorSpecies<Short> SPECIES_128

Вид, представляющий ShortVector с VectorShape.S_128_BIT.

SPECIES_256

public static final VectorSpecies<Short> SPECIES_256

Вид, представляющий ShortVector с VectorShape.S_256_BIT.

SPECIES_512

public static final VectorSpecies<Short> SPECIES_512

Вид, представляющий ShortVector с VectorShape.S_512_BIT.

SPECIES_MAX

public static final VectorSpecies<Short> SPECIES_MAX

Вид, представляющий ShortVector с VectorShape.S_Max_BIT.

SPECIES_PREFERRED

public static final VectorSpecies<Short> SPECIES_PREFERRED

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

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

zero

public static ShortVector zero(VectorSpecies<Short> species)

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

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

broadcast

public abstract ShortVector broadcast(short e)

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

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

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

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

Параметры:

e - значение для широковещательной передачи

Возвращает:

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

См. также:

broadcast

public static ShortVector broadcast(VectorSpecies<Short> species, short e)

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

Параметры:

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

e - значение для широковещательной передачи

Возвращает:

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

См. также:

broadcast

public abstract ShortVector broadcast(long e)

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

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

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

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

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

Параметры:

e - значение для широковещательной передачи

Возвращает:

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

См. также:

broadcast

public static ShortVector broadcast(VectorSpecies<Short> species, long e)

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

Параметры:

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

e - значение для широковещательной передачи

Возвращает:

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

Исключения:

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

См. также:

lanewise

public abstract ShortVector lanewise(VectorOperators.Unary op)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lanewise

public final ShortVector lanewise(VectorOperators.Unary op, VectorMask<Short> m)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.lanewise(VectorOperators.Unary)

lanewise

public abstract ShortVector lanewise(VectorOperators.Binary op, Vector<Short> v)

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise(VectorOperators.Binary,short,VectorMask)

lanewise

public final ShortVector lanewise(VectorOperators.Binary op, short e)

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Binary op, short e, VectorMask<Short> m)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

lanewise

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

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

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

lanewise

public abstract ShortVector lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2)

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

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

lanewise

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, short e1, short e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, short e1, short e2, VectorMask<Short> 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,short,short)

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2)

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

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2, VectorMask<Short> m)

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

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2)

Параметры:

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

lanewise

public final ShortVector lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2, VectorMask<Short> m)

Параметры:

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

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

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

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

Возвращает:

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

Исключения:

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

См. также:

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

add

public final ShortVector add(Vector<Short> v)

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

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

Указано в:

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

Параметры:

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

Возвращает:

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

См. также:

add(short)

add

public final ShortVector add(short e)

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

Параметры:

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

Возвращает:

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

См. также:

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

add

public final ShortVector add(Vector<Short> v, VectorMask<Short> m)

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

Указано в:

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

Параметры:

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

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

Возвращает:

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

См. также:

add(short,VectorMask)

add

public final ShortVector add(short e, VectorMask<Short> m)

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

Parameters:

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

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

Returns:

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

See Also:

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

sub

public final ShortVector sub(Vector<Short> v)

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

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

Specified by:

sub in class Vector<Short>

Parameters:

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

Returns:

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

See Also:

sub(short)

sub

public final ShortVector sub(short e)

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

Parameters:

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

Returns:

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

See Also:

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

sub

public final ShortVector sub(Vector<Short> v, VectorMask<Short> m)

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

Specified by:

sub in class Vector<Short>

Parameters:

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

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

Returns:

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

See Also:

sub(short,VectorMask)

sub

public final ShortVector sub(short e, VectorMask<Short> m)

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

Parameters:

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

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

Returns:

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

See Also:

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

mul

public final ShortVector mul(Vector<Short> v)

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

Specified by:

mul in class Vector<Short>

Parameters:

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

Returns:

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

See Also:

mul(short)

mul

public final ShortVector mul(short e)

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

Parameters:

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

Returns:

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

See Also:

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

mul

public final ShortVector mul(Vector<Short> v, VectorMask<Short> m)

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

Specified by:

mul in class Vector<Short>

Parameters:

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

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

Returns:

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

See Also:

mul(short,VectorMask)

умн

public final ShortVector mul(short e, VectorMask<Short> m)

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

Параметры:

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

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

Возвращает:

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

См. также:

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

дел

public final ShortVector div(Vector<Short> v)

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

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

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

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

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

Если есть делитель ноль,


 ArithmeticException

будет брошено.

Параметры:

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

Возвращает:

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

См. также:

дел

public final ShortVector div(short e)

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

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

Если есть делитель ноль,


 ArithmeticException

будет брошено.

Параметры:

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

Возвращает:

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

См. также:

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

дел

public final ShortVector div(Vector<Short> v, VectorMask<Short> m)

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

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

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

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

Если есть делитель ноль,


 ArithmeticException

будет брошено.

Параметры:

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

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

Возвращает:

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

См. также:

div(short,VectorMask)

дел

public final ShortVector div(short e, VectorMask<Short> m)

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

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

Если есть делитель ноль,


 ArithmeticException

будет брошено.

Параметры:

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

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

Возвращает:

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

См. также:

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

мин

public final ShortVector min(Vector<Short> v)

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

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

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

Параметры:

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

Возвращает:

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

См. также:

мин

public final ShortVector min(short e)

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

Параметры:

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

Возвращает:

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

См. также:

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

max

public final ShortVector max(Vector<Short> v)

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

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

Specified by:

max in class Vector<Short>

Parameters:

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

Returns:

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

See Also:

max

public final ShortVector max(short e)

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

Parameters:

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

Returns:

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

See Also:

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

and

public final ShortVector and(Vector<Short> v)

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

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

Parameters:

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

Returns:

побитовое & этого вектора и второго входного вектора

See Also:

and(short)
or(Vector)
not()
VectorOperators.AND
lanewise(VectorOperators.Binary,Vector,VectorMask)

and

public final ShortVector and(short e)

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

Parameters:

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

Returns:

побитовое & этого вектора и скаляра

See Also:

and(Vector)
VectorOperators.AND
lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final ShortVector or(Vector<Short> v)

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

Parameters:

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

Returns:

побитовое | этого вектора и второго входного вектора

See Also:

or(short)
and(Vector)
not()
VectorOperators.OR
lanewise(VectorOperators.Binary,Vector,VectorMask)

or

public final ShortVector or(short e)

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

Parameters:

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

Returns:

побитовое | этого вектора и скаляра

See Also:

or(Vector)
VectorOperators.OR
lanewise(VectorOperators.Binary,Vector,VectorMask)

neg

public final ShortVector neg()

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

Specified by:

neg in class Vector<Short>

Returns:

инверсия этого вектора

See Also:

abs

public final ShortVector abs()

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

Specified by:

abs in class Vector<Short>

Returns:

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

See Also:

not

public final ShortVector not()

Вычисляет побитовое логическое отрицание (~) этого вектора. Это операция по битам на уровне элементов, которая применяет примитивную побитовую операцию «not» (~) к каждому значению элемента. Этот метод также эквивалентен выражению lanewise(NOT).

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

Возвращает:

побитовое отрицание ~ этого вектора

См. также:

and(Vector)
VectorOperators.NOT
lanewise(VectorOperators.Unary,VectorMask)

eq

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

eq

public final VectorMask<Short> eq(short e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,short)

lt

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

lt

public final VectorMask<Short> lt(short e)

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

Параметры:

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,short)

test

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

test

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

Vector.test(VectorOperators.Test)

compare

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

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

Возвращает:

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

См. также:

Vector.compare(VectorOperators.Comparison, Vector)

compare

public abstract VectorMask<Short> compare(VectorOperators.Comparison op, short e)

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

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

Параметры:

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

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

Возвращает:

См. также:

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

END_OF_DOCUMENT_MARKER

compare

public final VectorMask<Short> compare(VectorOperators.Comparison op, short e, VectorMask<Short> m)

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

Параметры:

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

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

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

Возвращает:

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

См. также:

compare(VectorOperators.Comparison,Vector,VectorMask)

compare

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

compare

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

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

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

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

Параметры:

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

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

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

Возвращает:

См. также:

blend

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

addIndex

public abstract ShortVector 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<Short>
Параметры:: scale - число для умножения на каждый индекс разряда N, обычно 1
Возвращает:: результат увеличения каждого элемента разряда на его соответствующий индекс разряда N, масштабированный значением scale

blend

public final ShortVector blend(short e, VectorMask<Short> m)

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

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

blend

public final ShortVector blend(long e, VectorMask<Short> m)

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

slice

public abstract ShortVector slice(int origin, Vector<Short> 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 ShortVector slice(int origin, Vector<Short> w, VectorMask<Short> m)

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

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

Specified by:

slice in class Vector<Short>

Parameters:

origin - первый входной байт для переноса в срез

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

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

Returns:

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

See Also:

slice

public abstract ShortVector slice(int origin)

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


 (origin,

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

Parameters:

origin - первый входной байт для переноса в срез

Returns:

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

See Also:

unslice

public abstract ShortVector unslice(int origin, Vector<Short> w, int part)

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

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

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

Specified by:

unslice in class Vector<Short>

Parameters:

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

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

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

Returns:

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

See Also:

unslice

public abstract ShortVector unslice(int origin, Vector<Short> w, int part, VectorMask<Short> m)

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

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

Specified by:

unslice in class Vector<Short>

Parameters:

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

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

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

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

Returns:

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

See Also:

unslice

public abstract ShortVector unslice(int origin)

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


 (origin,

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

Specified by:

unslice in class Vector<Short>

Parameters:

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

Returns:

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

See Also:

rearrange

public abstract ShortVector rearrange(VectorShuffle<Short> m)

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

Specified by:

rearrange in class Vector<Short>

Parameters:

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

Returns:

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

See Also:

перестановка

public abstract ShortVector rearrange(VectorShuffle<Short> s, VectorMask<Short> 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<Short>

Параметры:

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

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

Возвращает:

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

См. также:

перестановка

public abstract ShortVector rearrange(VectorShuffle<Short> s, Vector<Short> 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<Short>

Параметры:

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

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

Возвращает:

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

См. также:

выборИз

public abstract ShortVector selectFrom(Vector<Short> v)

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

Указано:

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

Параметры:

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

Возвращает:

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

См. также:

Vector.rearrange(VectorShuffle)

выборИз

public abstract ShortVector selectFrom(Vector<Short> s, VectorMask<Short> m)

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

Указано:

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

Параметры:

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

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

Возвращает:

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

См. также:

побитовоеСлияние

public final ShortVector bitwiseBlend(Vector<Short> bits, Vector<Short> mask)

Объединяет биты двух векторов под управлением третьего, который предоставляет биты маски. Это троичная операция по дорожкам, выполняющая побитовое слияние операцию (a&~c)|(b&c) для каждой дорожки. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits - входные биты для слияния в текущий вектор

mask - битовая маска для включения слияния входных битов

Возвращает:

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

См. также:

bitwiseBlend(short,short)
bitwiseBlend(short,Vector)
bitwiseBlend(Vector,short)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)

побитовоеСлияние

public final ShortVector bitwiseBlend(short bits, short mask)

Объединяет биты вектора и скаляра под управлением другого скаляра, который предоставляет биты маски. Это троичная операция по дорожкам, выполняющая побитовое слияние операцию (a&~c)|(b&c) для каждой дорожки. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits - входные биты для слияния в текущий вектор

mask - битовая маска для включения слияния входных битов

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,short,short,VectorMask)

побитовоеСлияние

public final ShortVector bitwiseBlend(short bits, Vector<Short> mask)

Объединяет биты вектора и скаляра под управлением другого вектора, который предоставляет биты маски. Это троичная операция по дорожкам, выполняющая побитовое слияние операцию (a&~c)|(b&c) для каждой дорожки. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits - входные биты для слияния в текущий вектор

mask - битовая маска для включения слияния входных битов

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,short,Vector,VectorMask)

bitwiseBlend

public final ShortVector bitwiseBlend(Vector<Short> bits, short mask)

Объединяет биты двух векторов под управлением скаляра, который предоставляет биты маски. Это троичная операция по каждой строке, выполняющая побитовую операцию смешивания (a&~c)|(b&c) для каждого разряда. Этот метод также эквивалентен выражению lanewise(BITWISE_BLEND, bits, mask).

Параметры:

bits - биты входных данных для смешивания в текущий вектор

mask - побитовая маска для включения смешивания битов входных данных

Возвращает:

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

См. также:

bitwiseBlend(Vector,Vector)
VectorOperators.BITWISE_BLEND
lanewise(VectorOperators.Ternary,Vector,short,VectorMask)

reduceLanes

public abstract short reduceLanes(VectorOperators.Associative op)

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

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

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

Параметры:

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

Возвращает:

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

Исключения:

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

См. также:

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

reduceLanes

public abstract short reduceLanes(VectorOperators.Associative op, VectorMask<Short> m)

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

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

Если операция ADD, XOR, OR, или FIRST_NONZERO, то значение по умолчанию равно нулю, стандартное значение short.
Если операция MUL, то значение по умолчанию равно единице.
Если операция AND, то значение по умолчанию равно минус единице (все биты установлены).
Если операция MAX, то значение по умолчанию равно Short.MIN_VALUE.
Если операция MIN, то значение по умолчанию равно Short.MAX_VALUE.

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

Параметры:

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

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

Возвращает:

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

Исключения:

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

См. также:

reduceLanes(VectorOperators.Associative)

lane

public abstract short lane(int i)

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

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

withLane

public abstract ShortVector withLane(int i, short e)

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

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

toArray

public final short[] toArray()

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

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


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

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

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

Возвращает:

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

См. также:

toIntArray

public final int[] toIntArray()

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


 float

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

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

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

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

При использовании этого метода для векторов типа ShortVector, не будет потери точности или диапазона, и поэтому исключение UnsupportedOperationException не будет сгенерировано.

Возвращает:

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

См. также:

toLongArray

public final long[] toLongArray()

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


 float

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

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

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

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

Возвращает:

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

См. также:

toDoubleArray

public final double[] toDoubleArray()

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

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

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

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

При использовании этого метода на векторах типа ShortVector, потери точности не будет.

Возвращает:

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

См. также:

fromByteArray

public static ShortVector fromByteArray(VectorSpecies<Short> 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 ShortVector fromByteArray(VectorSpecies<Short> species, byte[] a, int offset, ByteOrder bo, VectorMask<Short> m)

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

Этот метод ведет себя так, как будто он возвращает результат вызова 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 ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset)

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

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

fromArray

public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)

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

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

fromArray

public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset)

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключение:

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

См. также:

toIntArray()

fromArray

public static ShortVector fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)

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

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

Параметры:

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

a - массив

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

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

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

Возвращает:

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

Исключение:

См. также:

toIntArray()

fromCharArray

public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset)

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

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

fromCharArray

public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)

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

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

fromCharArray

public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset)

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

Для каждого элемента вектора, где N — индекс элемента вектора, элемент загружается из выражения (short) 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()

fromCharArray

public static ShortVector fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)

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

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

Parameters:

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

a - массив

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

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

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

Returns:

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

Throws:

See Also:

toIntArray()

fromByteBuffer

public static ShortVector fromByteBuffer(VectorSpecies<Short> 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*2 < 0 или offset+N*2 >= bb.limit() для любого элемента N вектора

fromByteBuffer

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

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

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


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

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

intoArray

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

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

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

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

intoArray

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

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

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

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

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

intoArray

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

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

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

Parameters:

a - массив

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

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

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

Throws:

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

See Also:

toIntArray()

intoArray

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

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

See Also:

toIntArray()

intoCharArray

public final void intoCharArray(char[] a, int offset)

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

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

intoCharArray

public final void intoCharArray(char[] a, int offset, VectorMask<Short> m)

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

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

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

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

intoCharArray

public final void intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset)

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

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

Parameters:

a - массив

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

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

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

Throws:

See Also:

toIntArray()

intoCharArray

public final void intoCharArray(char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)

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

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

Parameters:

a - массив

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

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

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

m - маска

Throws:

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<Short>
Parameters:: a - массив байтов; offset - смещение в массиве; bo - желаемый порядок байтов

intoByteArray

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

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

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


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

Specified by:: intoByteArray в классе Vector<Short>
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<Short>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - желаемый порядок байтов

intoByteBuffer

public final void intoByteBuffer(ByteBuffer bb, int offset, ByteOrder bo, VectorMask<Short> 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<Short>
Parameters:: bb - буфер байтов; offset - смещение в массиве; bo - желаемый порядок байтов; m - маска, определяющая выбор элементов

reinterpretAsBytes

public final ByteVector reinterpretAsBytes()

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

Specified by:

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

Returns:

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

See Also:

viewAsIntegralLanes

public final ShortVector viewAsIntegralLanes()

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

Specified by:

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

Returns:

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

See Also:

viewAsFloatingLanes

public final Vector<?> viewAsFloatingLanes()

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

Specified by:

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

Implementation Note:

Этот метод всегда выбрасывает UnsupportedOperationException, так как нет типа с плавающей точкой того же размера, что и short. Тип возвращаемого значения этого метода произвольно назначен как Vector<?>. Будущие версии API могут изменить тип возвращаемого значения, если появятся дополнительные типы с плавающей точкой.

Returns:

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

See Also:

toString

public final String toString()

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

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

equals

public final boolean equals(Object obj)

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

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

Specified by:

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

Parameters:

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

Returns:

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

See Also:

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

hashCode

public final int hashCode()

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

Specified by:

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

Returns:

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

See Also:

species

public final VectorSpecies<Short> 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:

проверка

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

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

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

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

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

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

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

Параметры:

elementType - требуемый тип дорожки

Возвращает:

тот же вектор

См. также:

maskAll

public final VectorMask<Short> maskAll(boolean bit)

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

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

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

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

Параметры:

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

Возвращает:

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

См. также:

VectorSpecies.maskAll(boolean)

reinterpretAsShorts

public ShortVector reinterpretAsShorts()

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

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

reinterpretAsInts

public IntVector reinterpretAsInts()

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

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

reinterpretAsLongs

public LongVector reinterpretAsLongs()

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

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

reinterpretAsFloats

public FloatVector reinterpretAsFloats()

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

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

reinterpretAsDoubles

public DoubleVector reinterpretAsDoubles()

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

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

convert

public final <F> Vector<F> convert(VectorOperators.Conversion<Short,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).

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

castShape

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

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

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

Specified by:

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

Type Parameters:

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

Parameters:

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

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

Returns:

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

See Also:

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

public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Short,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/ShortVector.html