# 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, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static ByteVector`
ByteVector.`fromMemorySegment(VectorSpecies<Byte> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Byte> m)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask.
`static DoubleVector`
DoubleVector.`fromMemorySegment(VectorSpecies<Double> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static DoubleVector`
DoubleVector.`fromMemorySegment(VectorSpecies<Double> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Double> m)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask.
`static FloatVector`
FloatVector.`fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static FloatVector`
FloatVector.`fromMemorySegment(VectorSpecies<Float> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Float> m)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask.
`static IntVector`
IntVector.`fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static IntVector`
IntVector.`fromMemorySegment(VectorSpecies<Integer> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask.
`static LongVector`
LongVector.`fromMemorySegment(VectorSpecies<Long> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static LongVector`
LongVector.`fromMemorySegment(VectorSpecies<Long> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Long> m)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment and using a mask.
`static ShortVector`
ShortVector.`fromMemorySegment(VectorSpecies<Short> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
Loads a vector from a memory segmentPREVIEW starting at an offset into the memory segment.
`static ShortVector`
ShortVector.`fromMemorySegment(VectorSpecies<Short> species, MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Short> m)`
Loads a vector from a memory segmentPREVIEW 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.