Uses of Interface jdk.incubator.vector.VectorSpecies (Java SE 23 & JDK 23)
Description: use: module: jdk.incubator.vector, package: jdk.incubator.vector, interface: VectorSpecies

# Uses of Interface
jdk.incubator.vector.VectorSpecies

Packages that use VectorSpecies
Package
Description
jdk.incubator.vector
Incubating Feature. Will be removed in a future release.

- ## Uses of VectorSpecies in jdk.incubator.vector

  Fields in jdk.incubator.vector declared as VectorSpecies
  Modifier and Type
  Field
  Description
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_128`
  Species representing `ByteVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_128`
  Species representing `DoubleVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_128`
  Species representing `FloatVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_128`
  Species representing `IntVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_128`
  Species representing `LongVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_128`
  Species representing `ShortVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_256`
  Species representing `ByteVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_256`
  Species representing `DoubleVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_256`
  Species representing `FloatVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_256`
  Species representing `IntVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_256`
  Species representing `LongVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_256`
  Species representing `ShortVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_512`
  Species representing `ByteVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_512`
  Species representing `DoubleVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_512`
  Species representing `FloatVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_512`
  Species representing `IntVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_512`
  Species representing `LongVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_512`
  Species representing `ShortVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_64`
  Species representing `ByteVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_64`
  Species representing `DoubleVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_64`
  Species representing `FloatVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_64`
  Species representing `IntVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_64`
  Species representing `LongVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_64`
  Species representing `ShortVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_MAX`
  Species representing `ByteVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_MAX`
  Species representing `DoubleVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_MAX`
  Species representing `FloatVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_MAX`
  Species representing `IntVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_MAX`
  Species representing `LongVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_MAX`
  Species representing `ShortVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Byte>`
  ByteVector.`SPECIES_PREFERRED`
  Preferred species for `ByteVector`s.
  `static final VectorSpecies<Double>`
  DoubleVector.`SPECIES_PREFERRED`
  Preferred species for `DoubleVector`s.
  `static final VectorSpecies<Float>`
  FloatVector.`SPECIES_PREFERRED`
  Preferred species for `FloatVector`s.
  `static final VectorSpecies<Integer>`
  IntVector.`SPECIES_PREFERRED`
  Preferred species for `IntVector`s.
  `static final VectorSpecies<Long>`
  LongVector.`SPECIES_PREFERRED`
  Preferred species for `LongVector`s.
  `static final VectorSpecies<Short>`
  ShortVector.`SPECIES_PREFERRED`
  Preferred species for `ShortVector`s.
  Methods in jdk.incubator.vector that return VectorSpecies
  Modifier and Type
  Method
  Description
  `<F> VectorSpecies<F>`
  VectorSpecies.`check(Class<F> elementType)`
  Checks that this species has the given element type, and returns this species unchanged.
  `static <E> VectorSpecies<E>`
  VectorSpecies.`of(Class<E> elementType, VectorShape shape)`
  Finds a species for an element type and shape.
  `static <E> VectorSpecies<E>`
  VectorSpecies.`ofLargestShape(Class<E> etype)`
  Finds the largest vector species of the given element type.
  `static <E> VectorSpecies<E>`
  VectorSpecies.`ofPreferred(Class<E> etype)`
  Finds the species preferred by the current platform for a given vector element type.
  `abstract VectorSpecies<E>`
  Vector.`species()`
  Returns the species of this vector.
  `abstract VectorSpecies<E>`
  VectorMask.`vectorSpecies()`
  Returns the vector species to which this mask applies.
  `abstract VectorSpecies<E>`
  VectorShuffle.`vectorSpecies()`
  Returns the species of this shuffle.
  `<E> VectorSpecies<E>`
  VectorShape.`withLanes(Class<E> elementType)`
  Finds a vector species with the given element type and the current shape.
  `<F> VectorSpecies<F>`
  VectorSpecies.`withLanes(Class<F> newType)`
  Finds a species with the given element type and the same shape as this species.
  `VectorSpecies<E>`
  VectorSpecies.`withShape(VectorShape newShape)`
  Finds a species with the given shape and the same elementType as this species.
  Methods in jdk.incubator.vector with parameters of type VectorSpecies
  Modifier and Type
  Method
  Description
  `static ByteVector`
  ByteVector.`broadcast(VectorSpecies<Byte> species, byte e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static ByteVector`
  ByteVector.`broadcast(VectorSpecies<Byte> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static DoubleVector`
  DoubleVector.`broadcast(VectorSpecies<Double> species, double e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static DoubleVector`
  DoubleVector.`broadcast(VectorSpecies<Double> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static FloatVector`
  FloatVector.`broadcast(VectorSpecies<Float> species, float e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static FloatVector`
  FloatVector.`broadcast(VectorSpecies<Float> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static IntVector`
  IntVector.`broadcast(VectorSpecies<Integer> species, int e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static IntVector`
  IntVector.`broadcast(VectorSpecies<Integer> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static LongVector`
  LongVector.`broadcast(VectorSpecies<Long> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static ShortVector`
  ShortVector.`broadcast(VectorSpecies<Short> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `static ShortVector`
  ShortVector.`broadcast(VectorSpecies<Short> species, short e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `abstract <F> VectorMask<F>`
  VectorMask.`cast(VectorSpecies<F> species)`
  Converts this mask to a mask of the given species of element type `F`.
  `abstract <F> VectorShuffle<F>`
  VectorShuffle.`cast(VectorSpecies<F> species)`
  Converts this shuffle to a shuffle of the given species of element type `F`.
  `abstract <F> Vector<F>`
  Vector.`castShape(VectorSpecies<F> rsp, int part)`
  Convenience method for converting a vector from one lane type to another, reshaping as needed when lane sizes change.
  `abstract <F> Vector<F>`
  Vector.`check(VectorSpecies<F> species)`
  Checks that this vector has the given species, and returns this vector unchanged.
  `abstract <F> VectorMask<F>`
  VectorMask.`check(VectorSpecies<F> species)`
  Checks that this mask has the given species, and returns this mask unchanged.
  `abstract <F> VectorShuffle<F>`
  VectorShuffle.`check(VectorSpecies<F> species)`
  Checks that this shuffle has the given species, and returns this shuffle unchanged.
  `abstract <F> Vector<F>`
  Vector.`convertShape(VectorOperators.Conversion<E,F> conv, VectorSpecies<F> rsp, int part)`
  Converts this vector to a vector of the given species, shape and element type, converting lane values from the current `ETYPE` to a new lane type (called `FTYPE` here) according to the indicated conversion.
  `static ByteVector`
  ByteVector.`fromArray(VectorSpecies<Byte> species, byte[] a, int offset)`
  Loads a vector from an array of type `byte[]` starting at an offset.
  `static ByteVector`
  ByteVector.`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `byte[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ByteVector`
  ByteVector.`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`
  Gathers a new vector composed of elements from an array of type `byte[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ByteVector`
  ByteVector.`fromArray(VectorSpecies<Byte> species, byte[] a, int offset, VectorMask<Byte> m)`
  Loads a vector from an array of type `byte[]` starting at an offset and using a mask.
  `static DoubleVector`
  DoubleVector.`fromArray(VectorSpecies<Double> species, double[] a, int offset)`
  Loads a vector from an array of type `double[]` starting at an offset.
  `static DoubleVector`
  DoubleVector.`fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `double[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static DoubleVector`
  DoubleVector.`fromArray(VectorSpecies<Double> species, double[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Double> m)`
  Gathers a new vector composed of elements from an array of type `double[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static DoubleVector`
  DoubleVector.`fromArray(VectorSpecies<Double> species, double[] a, int offset, VectorMask<Double> m)`
  Loads a vector from an array of type `double[]` starting at an offset and using a mask.
  `static FloatVector`
  FloatVector.`fromArray(VectorSpecies<Float> species, float[] a, int offset)`
  Loads a vector from an array of type `float[]` starting at an offset.
  `static FloatVector`
  FloatVector.`fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `float[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static FloatVector`
  FloatVector.`fromArray(VectorSpecies<Float> species, float[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Float> m)`
  Gathers a new vector composed of elements from an array of type `float[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static FloatVector`
  FloatVector.`fromArray(VectorSpecies<Float> species, float[] a, int offset, VectorMask<Float> m)`
  Loads a vector from an array of type `float[]` starting at an offset and using a mask.
  `static IntVector`
  IntVector.`fromArray(VectorSpecies<Integer> species, int[] a, int offset)`
  Loads a vector from an array of type `int[]` starting at an offset.
  `static IntVector`
  IntVector.`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `int[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static IntVector`
  IntVector.`fromArray(VectorSpecies<Integer> species, int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`
  Gathers a new vector composed of elements from an array of type `int[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static IntVector`
  IntVector.`fromArray(VectorSpecies<Integer> species, int[] a, int offset, VectorMask<Integer> m)`
  Loads a vector from an array of type `int[]` starting at an offset and using a mask.
  `static LongVector`
  LongVector.`fromArray(VectorSpecies<Long> species, long[] a, int offset)`
  Loads a vector from an array of type `long[]` starting at an offset.
  `static LongVector`
  LongVector.`fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `long[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static LongVector`
  LongVector.`fromArray(VectorSpecies<Long> species, long[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Long> m)`
  Gathers a new vector composed of elements from an array of type `long[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static LongVector`
  LongVector.`fromArray(VectorSpecies<Long> species, long[] a, int offset, VectorMask<Long> m)`
  Loads a vector from an array of type `long[]` starting at an offset and using a mask.
  `static ShortVector`
  ShortVector.`fromArray(VectorSpecies<Short> species, short[] a, int offset)`
  Loads a vector from an array of type `short[]` starting at an offset.
  `static ShortVector`
  ShortVector.`fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `short[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ShortVector`
  ShortVector.`fromArray(VectorSpecies<Short> species, short[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`
  Gathers a new vector composed of elements from an array of type `short[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ShortVector`
  ShortVector.`fromArray(VectorSpecies<Short> species, short[] a, int offset, VectorMask<Short> m)`
  Loads a vector from an array of type `short[]` starting at an offset and using a mask.
  `static <E> VectorMask<E>`
  VectorMask.`fromArray(VectorSpecies<E> species, boolean[] bits, int offset)`
  Loads a mask from a `boolean` array starting at an offset.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)`
  Creates a shuffle for a given species from an `int` array starting at an offset.
  `static ByteVector`
  ByteVector.`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset)`
  Loads a vector from an array of type `boolean[]` starting at an offset.
  `static ByteVector`
  ByteVector.`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `boolean[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ByteVector`
  ByteVector.`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)`
  Gathers a new vector composed of elements from an array of type `boolean[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ByteVector`
  ByteVector.`fromBooleanArray(VectorSpecies<Byte> species, boolean[] a, int offset, VectorMask<Byte> m)`
  Loads a vector from an array of type `boolean[]` starting at an offset and using a mask.
  `static ShortVector`
  ShortVector.`fromCharArray(VectorSpecies<Short> species, char[] a, int offset)`
  Loads a vector from an array of type `char[]` starting at an offset.
  `static ShortVector`
  ShortVector.`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset)`
  Gathers a new vector composed of elements from an array of type `char[]`, using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ShortVector`
  ShortVector.`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Short> m)`
  Gathers a new vector composed of elements from an array of type `char[]`, under the control of a mask, and using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `static ShortVector`
  ShortVector.`fromCharArray(VectorSpecies<Short> species, char[] a, int offset, VectorMask<Short> m)`
  Loads a vector from an array of type `char[]` starting at an offset and using a mask.
  `static <E> VectorMask<E>`
  VectorMask.`fromLong(VectorSpecies<E> species, long bits)`
  Returns a mask where each lane is set or unset according to the bits in the given bitmask, starting with the least significant bit, and continuing up to the sign bit.
  `static ByteVector`
  ByteVector.`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static ByteVector`
  ByteVector.`fromMemorySegment(VectorSpecies<Byte> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static DoubleVector`
  DoubleVector.`fromMemorySegment(VectorSpecies<Double> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static DoubleVector`
  DoubleVector.`fromMemorySegment(VectorSpecies<Double> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Double> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static FloatVector`
  FloatVector.`fromMemorySegment(VectorSpecies<Float> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static FloatVector`
  FloatVector.`fromMemorySegment(VectorSpecies<Float> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Float> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static IntVector`
  IntVector.`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static IntVector`
  IntVector.`fromMemorySegment(VectorSpecies<Integer> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Integer> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static LongVector`
  LongVector.`fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static LongVector`
  LongVector.`fromMemorySegment(VectorSpecies<Long> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Long> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static ShortVector`
  ShortVector.`fromMemorySegment(VectorSpecies<Short> species, MemorySegment ms, long offset, ByteOrder bo)`
  Loads a vector from a memory segment starting at an offset into the memory segment.
  `static ShortVector`
  ShortVector.`fromMemorySegment(VectorSpecies<Short> species, MemorySegment ms, long offset, ByteOrder bo, VectorMask<Short> m)`
  Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`fromOp(VectorSpecies<E> species, IntUnaryOperator fn)`
  Creates a shuffle for a given species from the successive values of an operator applied to the range `[0..VLENGTH-1]`.
  `static <E> VectorMask<E>`
  VectorMask.`fromValues(VectorSpecies<E> species, boolean... bits)`
  Returns a mask where each lane is set or unset according to given `boolean` values.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`fromValues(VectorSpecies<E> species, int... sourceIndexes)`
  Creates a shuffle for a given species from a series of source indexes.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`iota(VectorSpecies<E> species, int start, int step, boolean wrap)`
  Creates a shuffle using source indexes set to sequential values starting from `start` and stepping by the given `step`.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`makeUnzip(VectorSpecies<E> species, int part)`
  Creates a shuffle which will unzip the concatenation of two vectors, alternatively storing input lanes into one or the other output vector.
  `static <E> VectorShuffle<E>`
  VectorShuffle.`makeZip(VectorSpecies<E> species, int part)`
  Creates a shuffle which will zip together two vectors, alternatively selecting lanes from one or the other.
  `int`
  VectorSpecies.`partLimit(VectorSpecies<?> outputSpecies, boolean lanewise)`
  Given this species and a second one, reports the net expansion or contraction of a (potentially) resizing reinterpretation cast or `lane-wise conversion` from this species to the second.
  `abstract <F> Vector<F>`
  Vector.`reinterpretShape(VectorSpecies<F> species, int part)`
  Transforms this vector to a vector of the given species of element type `F`, reinterpreting the bytes of this vector without performing any value conversions.
  `static ByteVector`
  ByteVector.`zero(VectorSpecies<Byte> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
  `static DoubleVector`
  DoubleVector.`zero(VectorSpecies<Double> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
  `static FloatVector`
  FloatVector.`zero(VectorSpecies<Float> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
  `static IntVector`
  IntVector.`zero(VectorSpecies<Integer> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
  `static LongVector`
  LongVector.`zero(VectorSpecies<Long> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
  `static ShortVector`
  ShortVector.`zero(VectorSpecies<Short> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.