Uses of Class jdk.incubator.vector.ByteVector (Java SE 23 & JDK 23)
Description: use: module: jdk.incubator.vector, package: jdk.incubator.vector, class: ByteVector

# Uses of Class
jdk.incubator.vector.ByteVector

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

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

  Methods in jdk.incubator.vector that return ByteVector
  Modifier and Type
  Method
  Description
  `final ByteVector`
  ByteVector.`abs()`
  Returns the absolute value of this vector.
  `final ByteVector`
  ByteVector.`add(byte e)`
  Adds this vector to the broadcast of an input scalar.
  `final ByteVector`
  ByteVector.`add(byte e, VectorMask<Byte> m)`
  Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`add(Vector<Byte> v)`
  Adds this vector to a second input vector.
  `final ByteVector`
  ByteVector.`add(Vector<Byte> v, VectorMask<Byte> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract ByteVector`
  ByteVector.`addIndex(int scale)`
  Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant.
  `final ByteVector`
  ByteVector.`and(byte e)`
  Computes the bitwise logical conjunction (`&`) of this vector and a scalar.
  `final ByteVector`
  ByteVector.`and(Vector<Byte> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`bitwiseBlend(byte bits, byte mask)`
  Blends together the bits of a vector and a scalar under the control of another scalar, which supplies mask bits.
  `final ByteVector`
  ByteVector.`bitwiseBlend(byte bits, Vector<Byte> mask)`
  Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
  `final ByteVector`
  ByteVector.`bitwiseBlend(Vector<Byte> bits, byte mask)`
  Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
  `final ByteVector`
  ByteVector.`bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)`
  Blends together the bits of two vectors under the control of a third, which supplies mask bits.
  `final ByteVector`
  ByteVector.`blend(byte e, VectorMask<Byte> m)`
  Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `final ByteVector`
  ByteVector.`blend(long e, VectorMask<Byte> m)`
  Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract ByteVector`
  ByteVector.`blend(Vector<Byte> v, VectorMask<Byte> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract ByteVector`
  ByteVector.`broadcast(byte e)`
  Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
  `abstract ByteVector`
  ByteVector.`broadcast(long e)`
  Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
  `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`.
  `abstract ByteVector`
  ByteVector.`compress(VectorMask<Byte> m)`
  Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
  `final ByteVector`
  ByteVector.`div(byte e)`
  Divides this vector by the broadcast of an input scalar.
  `final ByteVector`
  ByteVector.`div(byte e, VectorMask<Byte> m)`
  Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`div(Vector<Byte> v)`
  Divides this vector by a second input vector.
  `final ByteVector`
  ByteVector.`div(Vector<Byte> v, VectorMask<Byte> m)`
  Divides this vector by a second input vector under the control of a mask.
  `abstract ByteVector`
  ByteVector.`expand(VectorMask<Byte> m)`
  Expands the lane elements of this vector under the control of a specific mask.
  `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 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 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.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, byte e)`
  Combines the lane values of this vector with the value of a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, byte e, VectorMask<Byte> m)`
  Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, long e)`
  Combines the lane values of this vector with the value of a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, long e, VectorMask<Byte> m)`
  Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, Vector<Byte> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)`
  Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, byte e2)`
  Combines the lane values of this vector with the values of two broadcast scalars.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, byte e2, VectorMask<Byte> m)`
  Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> 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.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> 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.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)`
  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.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Unary op)`
  Operates on the lane values of this vector.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Unary op, VectorMask<Byte> m)`
  Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`max(byte e)`
  Computes the larger of this vector and the broadcast of an input scalar.
  `final ByteVector`
  ByteVector.`max(Vector<Byte> v)`
  Computes the larger of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`min(byte e)`
  Computes the smaller of this vector and the broadcast of an input scalar.
  `final ByteVector`
  ByteVector.`min(Vector<Byte> v)`
  Computes the smaller of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`mul(byte e)`
  Multiplies this vector by the broadcast of an input scalar.
  `final ByteVector`
  ByteVector.`mul(byte e, VectorMask<Byte> m)`
  Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`mul(Vector<Byte> v)`
  Multiplies this vector by a second input vector.
  `final ByteVector`
  ByteVector.`mul(Vector<Byte> v, VectorMask<Byte> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final ByteVector`
  ByteVector.`neg()`
  Negates this vector.
  `final ByteVector`
  ByteVector.`not()`
  Computes the bitwise logical complement (`~`) of this vector.
  `final ByteVector`
  ByteVector.`or(byte e)`
  Computes the bitwise logical disjunction (`|`) of this vector and a scalar.
  `final ByteVector`
  ByteVector.`or(Vector<Byte> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `abstract ByteVector`
  ByteVector.`rearrange(VectorShuffle<Byte> m)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
  `abstract ByteVector`
  ByteVector.`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`
  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.
  `abstract ByteVector`
  ByteVector.`rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `final ByteVector`
  ByteVector.`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.
  `final ByteVector`
  DoubleVector.`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.
  `final ByteVector`
  FloatVector.`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.
  `final ByteVector`
  IntVector.`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.
  `final ByteVector`
  LongVector.`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.
  `final ByteVector`
  ShortVector.`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.
  `abstract ByteVector`
  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.
  `abstract ByteVector`
  ByteVector.`selectFrom(Vector<Byte> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract ByteVector`
  ByteVector.`selectFrom(Vector<Byte> s, VectorMask<Byte> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract ByteVector`
  ByteVector.`slice(int origin)`
  Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector.
  `abstract ByteVector`
  ByteVector.`slice(int origin, Vector<Byte> v1)`
  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.
  `final ByteVector`
  ByteVector.`slice(int origin, Vector<Byte> w, VectorMask<Byte> m)`
  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.
  `final ByteVector`
  ByteVector.`sub(byte e)`
  Subtracts an input scalar from this vector.
  `final ByteVector`
  ByteVector.`sub(byte e, VectorMask<Byte> m)`
  Subtracts an input scalar from this vector under the control of a mask.
  `final ByteVector`
  ByteVector.`sub(Vector<Byte> v)`
  Subtracts a second input vector from this vector.
  `final ByteVector`
  ByteVector.`sub(Vector<Byte> v, VectorMask<Byte> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `abstract ByteVector`
  ByteVector.`unslice(int origin)`
  Reverses a slice(), inserting the current vector as a slice within a "background" input of zero lane values.
  `abstract ByteVector`
  ByteVector.`unslice(int origin, Vector<Byte> w, int part)`
  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.
  `abstract ByteVector`
  ByteVector.`unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)`
  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.
  `final ByteVector`
  ByteVector.`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.
  `abstract ByteVector`
  ByteVector.`withLane(int i, byte e)`
  Replaces the lane element of this vector at lane index `i` with value `e`.
  `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.