OpenJDK 27 · jdk.incubator.vector.ByteVector · APIdia, the JavaDoc alternative

Modifier and Type	Class and Description
pack-priv static class	ByteVector.ByteSpecies Class representing `ByteVector`'s of the same `VectorShape`.
pack-priv static interface	ByteVector.FBinOp
pack-priv static interface	ByteVector.FBinTest
pack-priv static interface	ByteVector.FLdLongOp
pack-priv static interface	ByteVector.FLdOp<M>
pack-priv static interface	ByteVector.FStLongOp
pack-priv static interface	ByteVector.FStOp<M>
pack-priv static interface	ByteVector.FTriOp
pack-priv static interface	ByteVector.FUnOp
pack-priv static interface	ByteVector.FVOp

Modifier and Type	Field and Description
pack-priv static final long	ARRAY_BASE
pack-priv static final long	ARRAY_BOOLEAN_BASE
pack-priv static final int	ARRAY_BOOLEAN_SHIFT
pack-priv static final int	ARRAY_SHIFT
private static final VectorOperators.ImplCache<VectorOperators.Binary, VectorSupport.BinaryOperation<ByteVector, VectorMask<Byte>>>	BIN_IMPL
private static final VectorOperators.ImplCache<VectorOperators.Binary, VectorSupport.VectorBroadcastIntOp<ByteVector, VectorMask<Byte>>>	BIN_INT_IMPL
pack-priv static final ValueLayout.OfByte	ELEMENT_LAYOUT
pack-priv static final int	FORBID_OPCODE_KIND
pack-priv static final int	LANE_TYPE_ORDINAL
pack-priv static final int	LANEBITS_TYPE_ORDINAL
private static final int	LSHR_SETUP_MASK
private static final byte	MAX_OR_INF
private static final byte	MIN_OR_INF
private static final VectorOperators.ImplCache<VectorOperators.Associative, VectorSupport.ReductionOperation<ByteVector, VectorMask<Byte>>>	REDUCE_IMPL
private static final int	SHIFT_MASK
public static final VectorSpecies<Byte>	SPECIES_128 Species representing `ByteVector`s of `VectorShape.S_128_BIT`.
public static final VectorSpecies<Byte>	SPECIES_256 Species representing `ByteVector`s of `VectorShape.S_256_BIT`.
public static final VectorSpecies<Byte>	SPECIES_512 Species representing `ByteVector`s of `VectorShape.S_512_BIT`.
public static final VectorSpecies<Byte>	SPECIES_64 Species representing `ByteVector`s of `VectorShape.S_64_BIT`.
public static final VectorSpecies<Byte>	SPECIES_MAX Species representing `ByteVector`s of `VectorShape.S_Max_BIT`.
public static final VectorSpecies<Byte>	SPECIES_PREFERRED Preferred species for `ByteVector`s.
private static final VectorOperators.ImplCache<VectorOperators.Ternary, VectorSupport.TernaryOperation<ByteVector, VectorMask<Byte>>>	TERN_IMPL
private static final byte	UMAX_VALUE
private static final byte	UMIN_VALUE
private static final VectorOperators.ImplCache<VectorOperators.Unary, VectorSupport.UnaryOperation<ByteVector, VectorMask<Byte>>>	UN_IMPL

Access	Constructor and Description
pack-priv	ByteVector(byte[] vec)

Method Summary

Modifier and Type	Method and Description
public final ByteVector	abs() Implements abstract jdk.incubator.vector.Vector.abs. Returns the absolute value of this vector.
public final ByteVector	add(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.add. Adds this vector to a second input vector.
public final ByteVector	Returns: the result of adding each lane of this vector to the scalar add(byte the input scalar e) Adds this vector to the broadcast of an input scalar.
public final ByteVector	add(Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.add. Adds this vector to a second input vector, selecting lanes under the control of a mask.
public final ByteVector	Returns: the result of adding each lane of this vector to the scalar add(byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
public abstract ByteVector	addIndex(int scale) Implements abstract jdk.incubator.vector.Vector.addIndex. Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant.
pack-priv final ByteVector	addIndexTemplate(int scale)
public final ByteVector	Returns: the bitwise `&` of this vector and the second input vector and(Vector<Byte> a second input vector v) Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
public final ByteVector	Returns: the bitwise `&` of this vector and scalar and(byte an input scalar e) Computes the bitwise logical conjunction (`&`) of this vector and a scalar.
pack-priv static long	arrayAddress(byte[] a, int index)
private static VectorSupport.BinaryOperation<ByteVector, VectorMask<Byte>>	binaryOperations(int opc_)
pack-priv static int	bitCount(byte a)
pack-priv final <F> VectorShuffle<F>	bitsToShuffle0(AbstractSpecies<F> dsp) Implements abstract jdk.incubator.vector.AbstractVector.bitsToShuffle0.
public final ByteVector	Returns: the bitwise blend of the given bits into the current vector, under control of the bitwise mask bitwiseBlend(Vector<Byte> input bits to blend into the current vector bits, Vector<Byte> a bitwise mask to enable blending of the input bits mask) Blends together the bits of two vectors under the control of a third, which supplies mask bits.
public final ByteVector	Returns: the bitwise blend of the given bits into the current vector, under control of the bitwise mask bitwiseBlend(byte input bits to blend into the current vector bits, byte a bitwise mask to enable blending of the input bits mask) Blends together the bits of a vector and a scalar under the control of another scalar, which supplies mask bits.
public final ByteVector	Returns: the bitwise blend of the given bits into the current vector, under control of the bitwise mask bitwiseBlend(byte input bits to blend into the current vector bits, Vector<Byte> a bitwise mask to enable blending of the input bits mask) Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
public final ByteVector	Returns: the bitwise blend of the given bits into the current vector, under control of the bitwise mask bitwiseBlend(Vector<Byte> input bits to blend into the current vector bits, byte a bitwise mask to enable blending of the input bits mask) Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
public abstract ByteVector	blend(Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.blend. Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
public final ByteVector	Returns: the result of blending the lane elements of this vector with the scalar value blend(byte the input scalar, containing the replacement lane value e, VectorMask<Byte> the mask controlling lane selection of the scalar m) Replaces selected lanes of this vector with a scalar value under the control of a mask.
public final ByteVector	Returns: the result of blending the lane elements of this vector with the scalar value blend(long the input scalar, containing the replacement lane value e, VectorMask<Byte> the mask controlling lane selection of the scalar m) Implements abstract jdk.incubator.vector.Vector.blend. Replaces selected lanes of this vector with a scalar value under the control of a mask.
pack-priv final <M extends VectorMask<Byte>> ByteVector	blendTemplate(Class<M> maskType, ByteVector v, M m)
pack-priv static long	booleanArrayAddress(boolean[] a, int index)
pack-priv abstract ByteVector	bOp(Vector<Byte> o, ByteVector.FBinOp f)
pack-priv abstract ByteVector	bOp(Vector<Byte> o, VectorMask<Byte> m, ByteVector.FBinOp f)
pack-priv final ByteVector	bOpTemplate(Vector<Byte> o, ByteVector.FBinOp f)
pack-priv final ByteVector	bOpTemplate(Vector<Byte> o, VectorMask<Byte> m, ByteVector.FBinOp f)
public abstract ByteVector	Returns: a vector where all lane elements are set to the primitive value `e` broadcast(byte the value to broadcast e) Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
public static ByteVector	Returns: a vector where all lane elements are set to the primitive value `e` broadcast(VectorSpecies<Byte> species of the desired vector species, byte the value to broadcast e) Returns a vector of the given species where all lane elements are set to the primitive value `e`.
public abstract ByteVector	broadcast(long e) Implements abstract jdk.incubator.vector.Vector.broadcast. Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
public static ByteVector	Returns: a vector where all lane elements are set to the primitive value `e` broadcast(VectorSpecies<Byte> species of the desired vector species, long the value to broadcast e) Returns a vector of the given species where all lane elements are set to the primitive value `e`.
private static VectorSupport.VectorBroadcastIntOp<ByteVector, VectorMask<Byte>>	broadcastIntOperations(int opc_)
pack-priv final ByteVector	broadcastTemplate(byte e)
pack-priv final ByteVector	broadcastTemplate(long e)
pack-priv final AbstractMask<Byte>	bTest(int cond, Vector<Byte> o, ByteVector.FBinTest f)
pack-priv static long	byteArrayAddress(byte[] a, int index)
public abstract VectorMask<Byte>	compare(VectorOperators.Comparison op, Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.compare. Tests this vector by comparing it with another input vector, according to the given comparison operation.
public abstract VectorMask<Byte>	Returns: the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator compare(VectorOperators.Comparison the operation used to compare lane values op, byte the input scalar e) Tests this vector by comparing it with an input scalar, according to the given comparison operation.
public final VectorMask<Byte>	Returns: the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator, and only in the lanes selected by the mask compare(VectorOperators.Comparison the operation used to compare lane values op, byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
public abstract VectorMask<Byte>	compare(VectorOperators.Comparison op, long e) Implements abstract jdk.incubator.vector.Vector.compare. Tests this vector by comparing it with an input scalar, according to the given comparison operation.
public final VectorMask<Byte>	compare(VectorOperators.Comparison op, long e, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.compare. Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
pack-priv final <M extends VectorMask<Byte>> M	compareTemplate(Class<M> maskType, VectorOperators.Comparison op, Vector<Byte> v)
pack-priv final <M extends VectorMask<Byte>> M	compareTemplate(Class<M> maskType, VectorOperators.Comparison op, Vector<Byte> v, M m)
pack-priv final <M extends VectorMask<Byte>> M	compareTemplate(Class<M> maskType, VectorOperators.Comparison op, byte e)
pack-priv final <M extends VectorMask<Byte>> M	compareTemplate(Class<M> maskType, VectorOperators.Comparison op, long e)
private static boolean	compareWithOp(int cond, byte a, byte b)
public abstract ByteVector	compress(VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.compress. Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
pack-priv static ByteVector	compressHelper(Vector<Byte> v, VectorMask<Byte> m)
pack-priv final <M extends AbstractMask<Byte>> ByteVector	compressTemplate(Class<M> masktype, M m)
private void	conditionalStoreNYI(int offset, ByteVector.ByteSpecies vsp, VectorMask<Byte> m, int scale, int limit)
public final ByteVector	div(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.div. Divides this vector by a second input vector.
public final ByteVector	Returns: the result of dividing each lane of this vector by the scalar div(byte the input scalar e) Divides this vector by the broadcast of an input scalar.
public final ByteVector	div(Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.div. Divides this vector by a second input vector under the control of a mask.
public final ByteVector	Returns: the result of dividing each lane of this vector by the scalar div(byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
public final VectorMask<Byte>	eq(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.eq. Tests if this vector is equal to another input vector.
public final VectorMask<Byte>	Returns: the result mask of testing if this vector is equal to `e` eq(byte the input scalar e) Tests if this vector is equal to an input scalar.
public final boolean	equals(Object obj) Implements abstract jdk.incubator.vector.Vector.equals. Indicates whether this vector is identical to some other object.
public abstract ByteVector	expand(VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.expand. Expands the lane elements of this vector under the control of a specific mask.
pack-priv static ByteVector	expandHelper(Vector<Byte> v, VectorMask<Byte> m)
pack-priv final <M extends AbstractMask<Byte>> ByteVector	expandTemplate(Class<M> masktype, M m)
public static ByteVector	Returns: the vector loaded from an array fromArray(VectorSpecies<Byte> species of desired vector species, byte[] the array a, int the offset into the array offset) Loads a vector from an array of type `byte[]` starting at an offset.
public static ByteVector	Returns: the vector loaded from an array fromArray(VectorSpecies<Byte> species of desired vector species, byte[] the array a, int the offset into the array offset, VectorMask<Byte> the mask controlling lane selection m) Loads a vector from an array of type `byte[]` starting at an offset and using a mask.
public static ByteVector	Returns: the vector loaded from the indexed elements of the array fromArray(VectorSpecies<Byte> species of desired vector species, byte[] the array a, int the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds offset, int[] the index map indexMap, int the offset into the index map 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.
public static ByteVector	Returns: the vector loaded from the indexed elements of the array fromArray(VectorSpecies<Byte> species of desired vector species, byte[] the array a, int the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds offset, int[] the index map indexMap, int the offset into the index map mapOffset, VectorMask<Byte> the mask controlling lane selection 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.
pack-priv abstract ByteVector	fromArray0(byte[] a, int offset)
pack-priv abstract ByteVector	fromArray0(byte[] a, int offset, VectorMask<Byte> m, int offsetInRange)
pack-priv abstract ByteVector	fromArray0(byte[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Byte> m)
pack-priv final ByteVector	fromArray0Template(byte[] a, int offset)
pack-priv final <M extends VectorMask<Byte>> ByteVector	fromArray0Template(Class<M> maskClass, byte[] a, int offset, M m, int offsetInRange)
pack-priv final <M extends VectorMask<Byte>> ByteVector	fromArray0Template(Class<M> maskClass, byte[] a, int offset, int[] indexMap, int mapOffset, M m)
pack-priv static byte	fromBits(long bits)
public static ByteVector	Returns: the vector loaded from an array fromBooleanArray(VectorSpecies<Byte> species of desired vector species, boolean[] the array a, int the offset into the array offset) Loads a vector from an array of type `boolean[]` starting at an offset.
public static ByteVector	Returns: the vector loaded from an array fromBooleanArray(VectorSpecies<Byte> species of desired vector species, boolean[] the array a, int the offset into the array offset, VectorMask<Byte> the mask controlling lane selection m) Loads a vector from an array of type `boolean[]` starting at an offset and using a mask.
public static ByteVector	Returns: the vector loaded from the indexed elements of the array fromBooleanArray(VectorSpecies<Byte> species of desired vector species, boolean[] the array a, int the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds offset, int[] the index map indexMap, int the offset into the index map 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.
public static ByteVector	Returns: the vector loaded from the indexed elements of the array fromBooleanArray(VectorSpecies<Byte> species of desired vector species, boolean[] the array a, int the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds offset, int[] the index map indexMap, int the offset into the index map mapOffset, VectorMask<Byte> the mask controlling lane selection 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.
pack-priv abstract ByteVector	fromBooleanArray0(boolean[] a, int offset)
pack-priv abstract ByteVector	fromBooleanArray0(boolean[] a, int offset, VectorMask<Byte> m, int offsetInRange)
pack-priv final ByteVector	fromBooleanArray0Template(boolean[] a, int offset)
pack-priv final <M extends VectorMask<Byte>> ByteVector	fromBooleanArray0Template(Class<M> maskClass, boolean[] a, int offset, M m, int offsetInRange)
public static ByteVector	Returns: a vector loaded from the memory segment fromMemorySegment(VectorSpecies<Byte> species of desired vector species, MemorySegment the memory segment ms, long the offset into the memory segment offset, ByteOrder the intended byte order bo) Loads a vector from a memory segment starting at an offset into the memory segment.
public static ByteVector	Returns: a vector loaded from the memory segment fromMemorySegment(VectorSpecies<Byte> species of desired vector species, MemorySegment the memory segment ms, long the offset into the memory segment offset, ByteOrder the intended byte order bo, VectorMask<Byte> the mask controlling lane selection m) Loads a vector from a memory segment starting at an offset into the memory segment and using a mask.
pack-priv abstract ByteVector	fromMemorySegment0(MemorySegment bb, long offset) Implements abstract jdk.incubator.vector.AbstractVector.fromMemorySegment0.
pack-priv abstract ByteVector	fromMemorySegment0(MemorySegment ms, long offset, VectorMask<Byte> m, int offsetInRange)
pack-priv final ByteVector	fromMemorySegment0Template(MemorySegment ms, long offset)
pack-priv final <M extends VectorMask<Byte>> ByteVector	fromMemorySegment0Template(Class<M> maskClass, MemorySegment ms, long offset, M m, int offsetInRange)
public final int	hashCode() Implements abstract jdk.incubator.vector.Vector.hashCode. Returns a hash code value for the vector.
public final void	intoArray(byte[] the array, of type `byte[]` a, int the offset into the array offset) Stores this vector into an array of type `byte[]` starting at an offset.
public final void	intoArray(byte[] the array, of type `byte[]` a, int the offset into the array offset, VectorMask<Byte> the mask controlling lane storage m) Stores this vector into an array of type `byte[]` starting at offset and using a mask.
public final void	intoArray(byte[] the array a, int an offset to combine with the index map offsets offset, int[] the index map indexMap, int the offset into the index map mapOffset) Scatters this vector into an array of type `byte[]` using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
public final void	intoArray(byte[] the array a, int an offset to combine with the index map offsets offset, int[] the index map indexMap, int the offset into the index map mapOffset, VectorMask<Byte> the mask m) Scatters this vector into 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.
pack-priv abstract void	intoArray0(byte[] a, int offset)
pack-priv abstract void	intoArray0(byte[] a, int offset, VectorMask<Byte> m)
pack-priv final void	intoArray0Template(byte[] a, int offset)
pack-priv final <M extends VectorMask<Byte>> void	intoArray0Template(Class<M> maskClass, byte[] a, int offset, M m)
public final void	intoBooleanArray(boolean[] the array a, int the offset into the array offset) Stores this vector into an array of type `boolean[]` starting at an offset.
public final void	intoBooleanArray(boolean[] the array a, int the offset into the array offset, VectorMask<Byte> the mask controlling lane storage m) Stores this vector into an array of type `boolean[]` starting at offset and using a mask.
public final void	intoBooleanArray(boolean[] the array a, int an offset to combine with the index map offsets offset, int[] the index map indexMap, int the offset into the index map mapOffset) Scatters this vector into an array of type `boolean[]` using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
public final void	intoBooleanArray(boolean[] the array a, int an offset to combine with the index map offsets offset, int[] the index map indexMap, int the offset into the index map mapOffset, VectorMask<Byte> the mask m) Scatters this vector into 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.
pack-priv abstract void	intoBooleanArray0(boolean[] a, int offset, VectorMask<Byte> m)
pack-priv final <M extends VectorMask<Byte>> void	intoBooleanArray0Template(Class<M> maskClass, boolean[] a, int offset, M m)
public final void	intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo) Implements abstract jdk.incubator.vector.Vector.intoMemorySegment. Stores this vector into a memory segment starting at an offset using explicit byte order.
public final void	intoMemorySegment(MemorySegment ms, long offset, ByteOrder bo, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.intoMemorySegment. Stores this vector into a memory segment starting at an offset using explicit byte order and a mask.
pack-priv final void	intoMemorySegment0(MemorySegment ms, long offset)
pack-priv abstract void	intoMemorySegment0(MemorySegment bb, long offset, VectorMask<Byte> m)
pack-priv final <M extends VectorMask<Byte>> void	intoMemorySegment0Template(Class<M> maskClass, MemorySegment ms, long offset, M m)
public abstract byte	Returns: the lane element at lane index `i` lane(int the lane index i) Gets the lane element at lane index `i`
public abstract ByteVector	lanewise(VectorOperators.Unary op) Implements abstract jdk.incubator.vector.Vector.lanewise. Operates on the lane values of this vector.
public abstract ByteVector	lanewise(VectorOperators.Unary op, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.lanewise. Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
public abstract ByteVector	lanewise(VectorOperators.Binary op, Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the corresponding lane values of this vector with those of a second input vector.
public abstract ByteVector	lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
public final ByteVector	Returns: the result of applying the operation lane-wise to the two input vectors lanewise(VectorOperators.Binary the operation used to process lane values op, byte the input scalar e) Combines the lane values of this vector with the value of a broadcast scalar.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vector and the scalar lanewise(VectorOperators.Binary the operation used to process lane values op, byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
public final ByteVector	lanewise(VectorOperators.Binary op, long e) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the lane values of this vector with the value of a broadcast scalar.
public final ByteVector	lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
public abstract ByteVector	lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
public abstract ByteVector	lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.lanewise. Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vector and the scalars lanewise(VectorOperators.Ternary the operation used to combine lane values op, byte the first input scalar e1, byte the second input scalar e2) Combines the lane values of this vector with the values of two broadcast scalars.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vector and the scalars lanewise(VectorOperators.Ternary the operation used to combine lane values op, byte the first input scalar e1, byte the second input scalar e2, VectorMask<Byte> the mask controlling lane selection m) Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vectors and the scalar lanewise(VectorOperators.Ternary the operation used to combine lane values op, Vector<Byte> the other input vector v1, byte the input scalar e2) Combines the lane values of this vector with the values of another vector and a broadcast scalar.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vectors and the scalar lanewise(VectorOperators.Ternary the operation used to combine lane values op, Vector<Byte> the other input vector v1, byte the input scalar e2, VectorMask<Byte> the mask controlling lane selection m) Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vectors and the scalar lanewise(VectorOperators.Ternary the operation used to combine lane values op, byte the input scalar e1, Vector<Byte> the other input vector v2) Combines the lane values of this vector with the values of another vector and a broadcast scalar.
public final ByteVector	Returns: the result of applying the operation lane-wise to the input vectors and the scalar lanewise(VectorOperators.Ternary the operation used to combine lane values op, byte the input scalar e1, Vector<Byte> the other input vector v2, VectorMask<Byte> the mask controlling lane selection m) Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
pack-priv abstract ByteVector	lanewiseShift(VectorOperators.Binary op, int e)
pack-priv abstract ByteVector	lanewiseShift(VectorOperators.Binary op, int e, VectorMask<Byte> m)
pack-priv final ByteVector	lanewiseShiftTemplate(VectorOperators.Binary op, int e)
pack-priv final ByteVector	lanewiseShiftTemplate(VectorOperators.Binary op, Class<? extends VectorMask<Byte>> maskClass, int e, VectorMask<Byte> m)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Unary op)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Unary op, Class<? extends VectorMask<Byte>> maskClass, VectorMask<Byte> m)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Binary op, Vector<Byte> v)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Binary op, Class<? extends VectorMask<Byte>> maskClass, Vector<Byte> v, VectorMask<Byte> m)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)
pack-priv final ByteVector	lanewiseTemplate(VectorOperators.Ternary op, Class<? extends VectorMask<Byte>> maskClass, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)
pack-priv final ByteVector	ldLongOp(MemorySegment memory, long offset, ByteVector.FLdLongOp f)
pack-priv final ByteVector	ldLongOp(MemorySegment memory, long offset, VectorMask<Byte> m, ByteVector.FLdLongOp f)
pack-priv final <M> ByteVector	ldOp(M memory, int offset, ByteVector.FLdOp<M> f)
pack-priv final <M> ByteVector	ldOp(M memory, int offset, VectorMask<Byte> m, ByteVector.FLdOp<M> f)
public final VectorMask<Byte>	lt(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.lt. Tests if this vector is less than another input vector.
public final VectorMask<Byte>	Returns: the mask result of testing if this vector is less than the input scalar lt(byte the input scalar e) Tests if this vector is less than an input scalar.
pack-priv final AbstractMask<Byte>	maskFactory(boolean[] bits) Build a mask directly using my species.
public final ByteVector	max(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.max. Computes the larger of this vector and a second input vector.
public final ByteVector	Returns: the result of multiplying this vector by the given scalar max(byte the input scalar e) Computes the larger of this vector and the broadcast of an input scalar.
pack-priv final ByteVector	maybeSwap(ByteOrder bo) Implements abstract jdk.incubator.vector.AbstractVector.maybeSwap.
pack-priv static byte	memorySegmentGet(MemorySegment ms, long o, int i)
pack-priv static void	memorySegmentSet(MemorySegment ms, long o, int i, byte e)
public final ByteVector	min(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.min. Computes the smaller of this vector and a second input vector.
public final ByteVector	Returns: the result of multiplying this vector by the given scalar min(byte the input scalar e) Computes the smaller of this vector and the broadcast of an input scalar.
public final ByteVector	mul(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.mul. Multiplies this vector by a second input vector.
public final ByteVector	Returns: the result of multiplying this vector by the given scalar mul(byte the input scalar e) Multiplies this vector by the broadcast of an input scalar.
public final ByteVector	mul(Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.mul. Multiplies this vector by a second input vector under the control of a mask.
public final ByteVector	Returns: the result of muling each lane of this vector to the scalar mul(byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
public final ByteVector	neg() Implements abstract jdk.incubator.vector.Vector.neg. Negates this vector.
public final ByteVector	Returns: the bitwise complement `~` of this vector not() Computes the bitwise logical complement (`~`) of this vector.
pack-priv static int	numberOfLeadingZeros(byte a)
pack-priv static int	numberOfTrailingZeros(byte a)
pack-priv static int	opCode(VectorOperators.Operator op)
pack-priv static int	opCode(VectorOperators.Operator op, int requireKind)
pack-priv static boolean	opKind(VectorOperators.Operator op, int bit)
public final ByteVector	Returns: the bitwise `\|` of this vector and the second input vector or(Vector<Byte> a second input vector v) Computes the bitwise logical disjunction (`\|`) of this vector and a second input vector.
public final ByteVector	Returns: the bitwise `\|` of this vector and scalar or(byte an input scalar e) Computes the bitwise logical disjunction (`\|`) of this vector and a scalar.
public abstract ByteVector	rearrange(VectorShuffle<Byte> shuffle) Implements abstract jdk.incubator.vector.Vector.rearrange. Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
public abstract ByteVector	rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.rearrange. Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
public abstract ByteVector	rearrange(VectorShuffle<Byte> s, Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.rearrange. Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
pack-priv final <S extends VectorShuffle<Byte>> ByteVector	rearrangeTemplate(Class<S> shuffletype, S shuffle)
pack-priv final <S extends VectorShuffle<Byte>, M extends VectorMask<Byte>> ByteVector	rearrangeTemplate(Class<S> shuffletype, Class<M> masktype, S shuffle, M m)
pack-priv final <S extends VectorShuffle<Byte>> ByteVector	rearrangeTemplate(Class<S> shuffletype, S shuffle, ByteVector v)
public abstract byte	Returns: the accumulated result reduceLanes(VectorOperators.Associative the operation used to combine lane values op) Returns a value accumulated from all the lanes of this vector.
public abstract byte	Returns: the reduced result accumulated from the selected lane values reduceLanes(VectorOperators.Associative the operation used to combine lane values op, VectorMask<Byte> the mask controlling lane selection m) Returns a value accumulated from selected lanes of this vector, controlled by a mask.
pack-priv final byte	reduceLanesTemplate(VectorOperators.Associative op, Class<? extends VectorMask<Byte>> maskClass, VectorMask<Byte> m)
pack-priv final byte	reduceLanesTemplate(VectorOperators.Associative op)
public abstract long	reduceLanesToLong(VectorOperators.Associative op) Implements abstract jdk.incubator.vector.Vector.reduceLanesToLong. Returns a value accumulated from all the lanes of this vector.
public abstract long	reduceLanesToLong(VectorOperators.Associative op, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.reduceLanesToLong. Returns a value accumulated from selected lanes of this vector, controlled by a mask.
private static VectorSupport.ReductionOperation<ByteVector, VectorMask<Byte>>	reductionOperations(int opc_)
public final ByteVector	reinterpretAsBytes() Implements abstract jdk.incubator.vector.Vector.reinterpretAsBytes. Views this vector as a vector of the same shape and contents but a lane type of `byte`, where the bytes are extracted from the lanes according to little-endian order.
pack-priv static byte	reverse(byte a)
pack-priv abstract byte	rOp(byte v, VectorMask<Byte> m, ByteVector.FBinOp f)
pack-priv final byte	rOpTemplate(byte v, VectorMask<Byte> m, ByteVector.FBinOp f)
pack-priv final byte	rOpTemplate(byte v, ByteVector.FBinOp f)
pack-priv static byte	rotateLeft(byte a, int n)
pack-priv static byte	rotateRight(byte a, int n)
public abstract ByteVector	selectFrom(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.selectFrom. Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
public abstract ByteVector	selectFrom(Vector<Byte> s, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.selectFrom. Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
public abstract ByteVector	selectFrom(Vector<Byte> v1, Vector<Byte> v2) Implements abstract jdk.incubator.vector.Vector.selectFrom. Using values stored in the lanes of this vector, assemble values stored in the second vector `v1` and third vector `v2`.
pack-priv final ByteVector	selectFromTemplate(ByteVector v)
pack-priv final <M extends VectorMask<Byte>> ByteVector	selectFromTemplate(ByteVector v, Class<M> masktype, M m)
pack-priv final ByteVector	selectFromTemplate(ByteVector v1, ByteVector v2)
pack-priv static ByteVector	selectFromTwoVectorHelper(Vector<Byte> indexes, Vector<Byte> src1, Vector<Byte> src2)
public abstract ByteVector	slice(int origin, Vector<Byte> v1) Implements abstract jdk.incubator.vector.AbstractVector.slice. Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
public final ByteVector	slice(int origin, Vector<Byte> w, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.slice. Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
public abstract ByteVector	slice(int origin) Implements abstract jdk.incubator.vector.AbstractVector.slice. Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector.
pack-priv final ByteVector	sliceTemplate(int origin, Vector<Byte> v1)
pack-priv final ByteVector	sliceTemplate(int origin)
pack-priv static ByteVector.ByteSpecies	Returns: a species for an element type of `byte` and shape species(VectorShape the shape s) Finds a species for an element type of `byte` and shape.
pack-priv final void	stLongOp(MemorySegment memory, long offset, ByteVector.FStLongOp f)
pack-priv final void	stLongOp(MemorySegment memory, long offset, VectorMask<Byte> m, ByteVector.FStLongOp f)
pack-priv final <M> void	stOp(M memory, int offset, ByteVector.FStOp<M> f)
pack-priv final <M> void	stOp(M memory, int offset, VectorMask<Byte> m, ByteVector.FStOp<M> f)
public final ByteVector	sub(Vector<Byte> v) Implements abstract jdk.incubator.vector.Vector.sub. Subtracts a second input vector from this vector.
public final ByteVector	Returns: the result of subtracting the scalar from each lane of this vector sub(byte the input scalar e) Subtracts an input scalar from this vector.
public final ByteVector	sub(Vector<Byte> v, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.sub. Subtracts a second input vector from this vector under the control of a mask.
public final ByteVector	Returns: the result of subtracting the scalar from each lane of this vector sub(byte the input scalar e, VectorMask<Byte> the mask controlling lane selection m) Subtracts an input scalar from this vector under the control of a mask.
pack-priv final ByteVector	swapIfNeeded(AbstractSpecies<?> srcSpecies) Implements abstract jdk.incubator.vector.AbstractVector.swapIfNeeded.
private static VectorSupport.TernaryOperation<ByteVector, VectorMask<Byte>>	ternaryOperations(int opc_)
public abstract VectorMask<Byte>	test(VectorOperators.Test op) Implements abstract jdk.incubator.vector.Vector.test. Tests the lanes of this vector according to the given operation.
public abstract VectorMask<Byte>	test(VectorOperators.Test op, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.test. Test selected lanes of this vector, according to the given operation.
pack-priv final <M extends VectorMask<Byte>> M	testTemplate(Class<M> maskType, VectorOperators.Test op)
pack-priv final <M extends VectorMask<Byte>> M	testTemplate(Class<M> maskType, VectorOperators.Test op, M mask)
public final byte[]	Returns: an array containing the lane values of this vector toArray() Implements abstract jdk.incubator.vector.Vector.toArray. Returns an array of type `byte[]` containing all the lane values.
pack-priv static long	toBits(byte e)
public final double[]	toDoubleArray() Implements abstract jdk.incubator.vector.Vector.toDoubleArray. Returns a `double[]` array containing all the lane values, converted to the type `double`.
public final int[]	toIntArray() Implements abstract jdk.incubator.vector.Vector.toIntArray. Returns an `int[]` array containing all the lane values, converted to the type `int`.
public final long[]	toLongArray() Implements abstract jdk.incubator.vector.Vector.toLongArray. Returns a `long[]` array containing all the lane values, converted to the type `long`.
pack-priv abstract ByteVector	tOp(Vector<Byte> o1, Vector<Byte> o2, ByteVector.FTriOp f)
pack-priv abstract ByteVector	tOp(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> m, ByteVector.FTriOp f)
pack-priv final ByteVector	tOpTemplate(Vector<Byte> o1, Vector<Byte> o2, ByteVector.FTriOp f)
pack-priv final ByteVector	tOpTemplate(Vector<Byte> o1, Vector<Byte> o2, VectorMask<Byte> m, ByteVector.FTriOp f)
pack-priv final <F> VectorShuffle<F>	toShuffle(AbstractSpecies<F> dsp, boolean wrap) Implements abstract jdk.incubator.vector.AbstractVector.toShuffle.
public final String	Returns: a string of the form `"[0,1,2...]"` reporting the lane values of this vector toString() Implements abstract jdk.incubator.vector.Vector.toString. Returns a string representation of this vector, of the form `"[0,1,2...]"`, reporting the lane values of this vector, in lane order.
private static VectorSupport.UnaryOperation<ByteVector, VectorMask<Byte>>	unaryOperations(int opc_)
public abstract ByteVector	unslice(int origin, Vector<Byte> w, int part) Implements abstract jdk.incubator.vector.Vector.unslice. Reverses a slice(), inserting the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
public abstract ByteVector	unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m) Implements abstract jdk.incubator.vector.Vector.unslice. Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
public abstract ByteVector	unslice(int origin) Implements abstract jdk.incubator.vector.Vector.unslice. Reverses a slice(), inserting the current vector as a slice within a "background" input of zero lane values.
pack-priv final ByteVector	unsliceTemplate(int origin, Vector<Byte> w, int part)
pack-priv final <M extends VectorMask<Byte>> ByteVector	unsliceTemplate(Class<M> maskType, int origin, Vector<Byte> w, int part, M m)
pack-priv final ByteVector	unsliceTemplate(int origin)
pack-priv abstract ByteVector	uOp(ByteVector.FUnOp f)
pack-priv abstract ByteVector	uOp(VectorMask<Byte> m, ByteVector.FUnOp f)
pack-priv final ByteVector	uOpTemplate(ByteVector.FUnOp f)
pack-priv final ByteVector	uOpTemplate(VectorMask<Byte> m, ByteVector.FUnOp f)
pack-priv abstract byte[]	vec()
pack-priv abstract ByteVector	vectorFactory(byte[] vec) Build a vector directly using my own constructor.
public final Vector<?>	viewAsFloatingLanes() Implements abstract jdk.incubator.vector.Vector.viewAsFloatingLanes. Views this vector as a vector of the same shape, length, and contents, but a lane type that is a floating-point type.
public final ByteVector	viewAsIntegralLanes() Implements abstract jdk.incubator.vector.Vector.viewAsIntegralLanes. Views this vector as a vector of the same shape, length, and contents, but a lane type that is not a floating-point type.
pack-priv final ByteVector	vOp(ByteVector.FVOp f)
pack-priv final ByteVector	vOp(VectorMask<Byte> m, ByteVector.FVOp f)
pack-priv abstract ByteVector.ByteSpecies	vspecies() Implements abstract jdk.incubator.vector.AbstractVector.vspecies.
public abstract ByteVector	Returns: the result of replacing the lane element of this vector at lane index `i` with value `e`. withLane(int the lane index of the lane element to be replaced i, byte the value to be placed e) Replaces the lane element of this vector at lane index `i` with value `e`.
private ArrayIndexOutOfBoundsException	wrongPartForSlice(int part)
public static ByteVector	Returns: a zero vector zero(VectorSpecies<Byte> species of the desired zero vector species) Returns a vector of the given species where all lane elements are set to zero, the default primitive value.

public abstract sealed Class ByteVector

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary