Интерфейс VectorSpecies<E>

Class<E> elementType()

Возвращает примитивный тип элемента векторов данного вида.

Class<? extends Vector<E>> vectorType()

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

Class<? extends VectorMask<E>> maskType()

Возвращает тип маски вектора для данного вида.

int elementSize()

Возвращает размер дорожки, в битах, векторов данного вида.

VectorShape vectorShape()

Возвращает форму векторов, созданных данным видом.

int length()

Возвращает количество дорожек в векторе данного вида.

int vectorBitSize()

Возвращает общий размер вектора, в битах, любого вектора данного вида. Это то же значение, что и this.vectorShape().vectorBitSize().

int vectorByteSize()

Возвращает общий размер вектора, в байтах, любого вектора данного вида. Это то же значение, что и this.vectorShape().vectorBitSize() / Byte.SIZE.

int loopBound(int length)

Функция управления циклом, которая возвращает наибольшее кратное VLENGTH , которое меньше или равно заданному значению length. Здесь VLENGTH является результатом this.length(), а length интерпретируется как количество дорожек. Результирующее значение R удовлетворяет этому неравенству:

R <= length < R+VLENGTH
 

Конкретно, этот метод вычисляет length - floorMod(length, VLENGTH), где floorMod вычисляет остаток, округляя частное к отрицательной бесконечности. Пока VLENGTH является степенью двойки, результат также равен length & ~(VLENGTH - 1).

VectorMask<E> indexInRange(int offset, int limit)

Возвращает маску данного вида, где установлены только дорожки в индексе N, такие что скорректированный индекс N+offset находится в диапазоне [0..limit-1].

Этот метод возвращает значение выражения maskAll(true).indexInRange(offset, limit)

<F> VectorSpecies<F> check(Class<F> elementType)

Проверяет, что у данного вида есть заданный тип элемента, и возвращает этот вид без изменений. Эффект аналогичен этому псевдокоду: elementType == elementType() ? this : throw new ClassCastException().

int partLimit(VectorSpecies<?> outputSpecies, boolean lanewise)

Учитывая этот вид и второй, сообщает о чистом расширении или сокращении (возможно) изменяющей размер переинтерпретации формы или lane-wise conversion от этого вида ко второму. Знак и величина возвращаемого значения зависят от разницы в размерах между предлагаемым входом и выходом форм, и (необязательно, если lanewise истинно) также от разницы в размерах между предлагаемым входом и выходом дорожек.

• Сначала определяется логический размер результата. Если lanewise ложно, этот размер такой же, как у входного VSHAPE. Если lanewise истинно, логический размер результата равен произведению входного VLENGTH на размер выходного ETYPE.
• Затем логический размер результата сравнивается с размером предлагаемой формы вывода, чтобы увидеть, как он впишется.
• Если логический результат точно вписывается в форму вывода, возвращаемое значение равно нулю, что означает отсутствие чистого расширения или сокращения.
• Если логический результат превысит форму вывода, возвращаемое значение — это отношение (больше единицы) логического размера результата к (меньшему) размеру вывода. Это отношение можно рассматривать как измерение пропорции «потерянных битов ввода», которые необходимо удалить из ввода, чтобы результат поместился в вектор вывода. Это также предельная часть, верхняя граница (не включая) параметра part к методу, который преобразовал бы вид ввода в вид вывода.
• Если логический результат поместится в форму вывода с избытком места, возвращаемое значение — отрицательное число, абсолютное значение которого является отношением (больше единицы) между размером вывода и (меньшим) логическим размером результата. Это отношение можно рассматривать как измерение пропорции «дополнительных битов заполнения», которые необходимо добавить к логическому результату, чтобы заполнить вектор вывода. Это также предельная часть, нижняя граница (не включая) параметра part к методу, который преобразовал бы вид ввода в вид вывода.

<F> VectorSpecies<F> withLanes(Class<F> newType)

Находит вид с заданным типом элемента и той же формой, что и этот вид. Возвращает то же значение, что и VectorSpecies.of(newType, this.vectorShape()).

VectorSpecies<E> withShape(VectorShape newShape)

Находит вид с заданной формой и тем же elementType, что и этот вид. Возвращает то же значение, что и VectorSpecies.of(this.elementType(), newShape).

static <E> VectorSpecies<E> of(Class<E> elementType, VectorShape shape)

Находит вид для типа элемента и формы.

static <E> VectorSpecies<E> ofLargestShape(Class<E> etype)

Находит наибольший векторный вид заданного типа элемента.

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

static <E> VectorSpecies<E> ofPreferred(Class<E> etype)

Находит вид, предпочитаемый текущей платформой, для заданного векторного типа элемента. Это то же самое значение, что и VectorSpecies.of(etype, VectorShape.preferredShape()).

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

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

static int elementSize(Class<?> elementType)

Возвращает размер в битах заданного векторного типа элемента (ETYPE). Тип элемента должен быть допустимым ETYPE, а не типом-обёрткой или другим типом объекта. Аргумент типа элемента должен быть зеркалом для допустимого векторного ETYPE, такого как byte.class, int.class, или double.class. Размер в битах такого типа — это константа SIZE для соответствующего класса-обёртки, такого как Byte.SIZE, или Integer.SIZE, или Double.SIZE.

Vector<E> zero()

Возвращает вектор этого вида, где все элементы проходов установлены в значение по умолчанию для примитивного типа, (ETYPE)0. Эквивалентно IntVector.zero(this) или эквивалентному методу zero для типа вектора, соответствующего этому виду.

Vector<E> fromArray(Object a, int offset)

Возвращает вектор этого вида, где элементы проходов инициализируются из заданного массива по заданному смещению. Массив должен быть соответствующего ETYPE. Эквивалентно IntVector.fromArray(this,a,offset) или эквивалентному методу fromArray для типа вектора, соответствующего этому виду.

Vector<E> fromByteArray(byte[] a, int offset, ByteOrder bo)

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

Эквивалентно IntVector.fromByteArray(this,a,offset,bo) или эквивалентному методу fromByteArray для типа вектора, соответствующего этому виду.

VectorMask<E> loadMask(boolean[] bits, int offset)

Возвращает маску этого вида, где элементы проходов инициализируются из заданного массива по заданному смещению. Эквивалентно VectorMask.fromArray(this,a,offset).

VectorMask<E> maskAll(boolean bit)

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

Vector<E> broadcast(long e)

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

Этот метод возвращает значение этого выражения: EVector.broadcast(this, (ETYPE)e), где EVector — это класс вектора, специфичный для ETYPE этого вида. Значение long должно быть точно представимо ETYPE, чтобы e==(long)(ETYPE)e.

long checkValue(long e)

Проверяет, может ли этот вид представлять данное значение элемента, и возвращает значение без изменений. Значение long должно быть точно представимо ETYPE вида вектора, чтобы e==(long)(ETYPE)e. Эффект похож на этот псевдокод: e == (long)(ETYPE)e ? e : throw new IllegalArgumentException().

VectorShuffle<E> shuffleFromValues(int... sourceIndexes)

Создаёт перемешивание для этого вида из серии индексов источников.

Для каждой дорожки перемешивания, где N - индекс дорожки перемешивания, значение N-го индекса проверяется на соответствие виду VLENGTH, и (если не соответствует) частично обертывается в исключительный индекс в диапазоне [-VLENGTH..-1].

VectorShuffle<E> shuffleFromArray(int[] sourceIndexes, int offset)

Создаёт перемешивание для этого вида из массива int начиная со смещения.

Для каждой дорожки перемешивания, где N - индекс дорожки перемешивания, элемент массива с индексом i + N проверяется на соответствие виду VLENGTH, и (если не соответствует) частично обертывается в исключительный индекс в диапазоне [-VLENGTH..-1].

VectorShuffle<E> shuffleFromOp(IntUnaryOperator fn)

Создаёт перемешивание для этого вида из последовательных значений оператора, применённого к диапазону [0..VLENGTH-1].

Для каждой дорожки перемешивания, где N - индекс дорожки перемешивания, значение N-го индекса проверяется на соответствие виду VLENGTH, и (если не соответствует) частично обертывается в исключительный индекс в диапазоне [-VLENGTH..-1].

Следует позаботиться о том, чтобы значения VectorShuffle производимые этим методом, потреблялись как константы, чтобы обеспечить оптимальное генерирование кода. Например, значения перемешивания могут храниться в static final полях или в инвариантных циклах локальных переменных.

Этот метод ведёт себя так, как будто перемешивание создаётся из массива индексов, преобразованных следующим образом:

   int[] a = new int[VLENGTH];
   for (int i = 0; i < a.length; i++) {
       a[i] = fn.applyAsInt(i);
   }
   return VectorShuffle.fromArray(this, a, 0);
 

VectorShuffle<E> iotaShuffle(int start, int step, boolean wrap)

Создаёт перемешивание, используя индексы источников, установленные в последовательные значения, начиная с start и шагом заданным step.

Этот метод возвращает значение выражения VectorSpecies.shuffleFromOp(i -> R(start + i * step)), где R - wrapIndex, если wrap - true, и является тождественной функцией в противном случае.

Если wrap - false, каждый индекс проверяется на соответствие виду VLENGTH, и (если не соответствует) частично обертывается в исключительный индекс в диапазоне [-VLENGTH..-1]. В противном случае, если wrap - true, также уменьшите каждый индекс, как если бы по wrapIndex, до допустимого диапазона [0..VLENGTH-1].

String toString()

Возвращает строку вида "Species[ETYPE, VLENGTH, SHAPE]", где ETYPE - примитивный тип дорожки, VLENGTH - количество дорожек вектора, связанное со видом, и SHAPE - форма вектора, связанная со видом.

boolean equals(Object obj)

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

int hashCode()

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