Module jdk.incubator.vector
Package jdk.incubator.vector

# Class IntVector

java.lang.Object
jdk.incubator.vector.Vector<E>
jdk.incubator.vector.IntVector

public abstract class IntVector extends Vector<E>
`IntVector` relies on preview features of the Java platform:

- `IntVector` refers to one or more preview APIs: `MemorySegment`.

Programs can only use `IntVector` when preview features are enabled.
Preview features may be removed in a future release, or upgraded to permanent features of the Java platform.
A specialized `Vector` representing an ordered immutable sequence of `int` values.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final VectorSpecies<Integer>`
  `SPECIES_128`
  Species representing `IntVector`s of `VectorShape.S_128_BIT`.
  `static final VectorSpecies<Integer>`
  `SPECIES_256`
  Species representing `IntVector`s of `VectorShape.S_256_BIT`.
  `static final VectorSpecies<Integer>`
  `SPECIES_512`
  Species representing `IntVector`s of `VectorShape.S_512_BIT`.
  `static final VectorSpecies<Integer>`
  `SPECIES_64`
  Species representing `IntVector`s of `VectorShape.S_64_BIT`.
  `static final VectorSpecies<Integer>`
  `SPECIES_MAX`
  Species representing `IntVector`s of `VectorShape.S_Max_BIT`.
  `static final VectorSpecies<Integer>`
  `SPECIES_PREFERRED`
  Preferred species for `IntVector`s.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `final IntVector`
  `abs()`
  Returns the absolute value of this vector.
  `final IntVector`
  `add(int e)`
  Adds this vector to the broadcast of an input scalar.
  `final IntVector`
  `add(int e, VectorMask<Integer> m)`
  Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final IntVector`
  `add(Vector<Integer> v)`
  Adds this vector to a second input vector.
  `final IntVector`
  `add(Vector<Integer> v, VectorMask<Integer> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract IntVector`
  `addIndex(int scale)`
  Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant.
  `final IntVector`
  `and(int e)`
  Computes the bitwise logical conjunction (`&`) of this vector and a scalar.
  `final IntVector`
  `and(Vector<Integer> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final IntVector`
  `bitwiseBlend(int bits, int mask)`
  Blends together the bits of a vector and a scalar under the control of another scalar, which supplies mask bits.
  `final IntVector`
  `bitwiseBlend(int bits, Vector<Integer> mask)`
  Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
  `final IntVector`
  `bitwiseBlend(Vector<Integer> bits, int mask)`
  Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
  `final IntVector`
  `bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)`
  Blends together the bits of two vectors under the control of a third, which supplies mask bits.
  `final IntVector`
  `blend(int e, VectorMask<Integer> m)`
  Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `final IntVector`
  `blend(long e, VectorMask<Integer> m)`
  Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract IntVector`
  `blend(Vector<Integer> v, VectorMask<Integer> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract IntVector`
  `broadcast(int e)`
  Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
  `abstract IntVector`
  `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 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`
  `broadcast(VectorSpecies<Integer> species, long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `final <F> Vector<F>`
  `castShape(VectorSpecies<F> toSpecies, int part)`
  Convenience method for converting a vector from one lane type to another, reshaping as needed when lane sizes change.
  `final <F> Vector<F>`
  `check(Class<F> elementType)`
  Checks that this vector has the given element type, and returns this vector unchanged.
  `final <F> Vector<F>`
  `check(VectorSpecies<F> species)`
  Checks that this vector has the given species, and returns this vector unchanged.
  `abstract VectorMask<Integer>`
  `compare(VectorOperators.Comparison op, int e)`
  Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `final VectorMask<Integer>`
  `compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)`
  Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Integer>`
  `compare(VectorOperators.Comparison op, long e)`
  Tests this vector by comparing it with an input scalar, according to the given comparison operation.
  `final VectorMask<Integer>`
  `compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)`
  Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask.
  `abstract VectorMask<Integer>`
  `compare(VectorOperators.Comparison op, Vector<Integer> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract IntVector`
  `compress(VectorMask<Integer> m)`
  Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
  `final <F> Vector<F>`
  `convert(VectorOperators.Conversion<Integer,F> conv, int part)`
  Convert this vector to a vector of the same shape and a new element type, converting lane values from the current `ETYPE` to a new lane type (called `FTYPE` here) according to the indicated conversion.
  `abstract <F> Vector<F>`
  `convertShape(VectorOperators.Conversion<Integer,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.
  `final IntVector`
  `div(int e)`
  Divides this vector by the broadcast of an input scalar.
  `final IntVector`
  `div(int e, VectorMask<Integer> m)`
  Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final IntVector`
  `div(Vector<Integer> v)`
  Divides this vector by a second input vector.
  `final IntVector`
  `div(Vector<Integer> v, VectorMask<Integer> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final VectorMask<Integer>`
  `eq(int e)`
  Tests if this vector is equal to an input scalar.
  `final VectorMask<Integer>`
  `eq(Vector<Integer> v)`
  Tests if this vector is equal to another input vector.
  `final boolean`
  `equals(Object obj)`
  Indicates whether this vector is identical to some other object.
  `abstract IntVector`
  `expand(VectorMask<Integer> m)`
  Expands the lane elements of this vector under the control of a specific mask.
  `static IntVector`
  `fromArray(VectorSpecies<Integer> species, int[] a, int offset)`
  Loads a vector from an array of type `int[]` starting at an offset.
  `static 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`
  `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`
  `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 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`
  `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.
  `protected final Object`
  `getPayload()`
  `final int`
  `hashCode()`
  Returns a hash code value for the vector.
  `final void`
  `intoArray(int[] a, int offset)`
  Stores this vector into an array of type `int[]` starting at an offset.
  `final void`
  `intoArray(int[] a, int offset, int[] indexMap, int mapOffset)`
  Scatters this vector into an array of type `int[]` using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map.
  `final void`
  `intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)`
  Scatters this vector into 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.
  `final void`
  `intoArray(int[] a, int offset, VectorMask<Integer> m)`
  Stores this vector into an array of type `int[]` starting at offset and using a mask.
  `final void`
  `intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
  Stores this vector into a memory segmentPREVIEW starting at an offset using explicit byte order.
  `final void`
  `intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)`
  Stores this vector into a memory segmentPREVIEW starting at an offset using explicit byte order and a mask.
  `abstract int`
  `lane(int i)`
  Gets the lane element at lane index `i`
  `final IntVector`
  `lanewise(VectorOperators.Binary op, int e)`
  Combines the lane values of this vector with the value of a broadcast scalar.
  `final IntVector`
  `lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Binary op, long e)`
  Combines the lane values of this vector with the value of a broadcast scalar.
  `final IntVector`
  `lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Binary op, Vector<Integer> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract IntVector`
  `lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Ternary op, int e1, int e2)`
  Combines the lane values of this vector with the values of two broadcast scalars.
  `final IntVector`
  `lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final IntVector`
  `lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final IntVector`
  `lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract IntVector`
  `lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> 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 IntVector`
  `lanewise(VectorOperators.Unary op)`
  Operates on the lane values of this vector.
  `abstract IntVector`
  `lanewise(VectorOperators.Unary op, VectorMask<Integer> m)`
  Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `final VectorMask<Integer>`
  `lt(int e)`
  Tests if this vector is less than an input scalar.
  `final VectorMask<Integer>`
  `lt(Vector<Integer> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Integer>`
  `maskAll(boolean bit)`
  Returns a mask of same species as this vector, where each lane is set or unset according to given single boolean, which is broadcast to all lanes.
  `final IntVector`
  `max(int e)`
  Computes the larger of this vector and the broadcast of an input scalar.
  `final IntVector`
  `max(Vector<Integer> v)`
  Computes the larger of this vector and a second input vector.
  `final IntVector`
  `min(int e)`
  Computes the smaller of this vector and the broadcast of an input scalar.
  `final IntVector`
  `min(Vector<Integer> v)`
  Computes the smaller of this vector and a second input vector.
  `final IntVector`
  `mul(int e)`
  Multiplies this vector by the broadcast of an input scalar.
  `final IntVector`
  `mul(int e, VectorMask<Integer> m)`
  Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask.
  `final IntVector`
  `mul(Vector<Integer> v)`
  Multiplies this vector by a second input vector.
  `final IntVector`
  `mul(Vector<Integer> v, VectorMask<Integer> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final IntVector`
  `neg()`
  Negates this vector.
  `final IntVector`
  `not()`
  Computes the bitwise logical complement (`~`) of this vector.
  `final IntVector`
  `or(int e)`
  Computes the bitwise logical disjunction (`|`) of this vector and a scalar.
  `final IntVector`
  `or(Vector<Integer> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `abstract IntVector`
  `rearrange(VectorShuffle<Integer> m)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
  `abstract IntVector`
  `rearrange(VectorShuffle<Integer> s, Vector<Integer> 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 IntVector`
  `rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract int`
  `reduceLanes(VectorOperators.Associative op)`
  Returns a value accumulated from all the lanes of this vector.
  `abstract int`
  `reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)`
  Returns a value accumulated from selected lanes of this vector, controlled by a mask.
  `final 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.
  `DoubleVector`
  `reinterpretAsDoubles()`
  Reinterprets this vector as a vector of the same shape and contents but a lane type of `double`, where the lanes are assembled from successive bytes according to little-endian order.
  `FloatVector`
  `reinterpretAsFloats()`
  Reinterprets this vector as a vector of the same shape and contents but a lane type of `float`, where the lanes are assembled from successive bytes according to little-endian order.
  `IntVector`
  `reinterpretAsInts()`
  Reinterprets this vector as a vector of the same shape and contents but a lane type of `int`, where the lanes are assembled from successive bytes according to little-endian order.
  `LongVector`
  `reinterpretAsLongs()`
  Reinterprets this vector as a vector of the same shape and contents but a lane type of `long`, where the lanes are assembled from successive bytes according to little-endian order.
  `ShortVector`
  `reinterpretAsShorts()`
  Reinterprets this vector as a vector of the same shape and contents but a lane type of `short`, where the lanes are assembled from successive bytes according to little-endian order.
  `abstract IntVector`
  `selectFrom(Vector<Integer> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract IntVector`
  `selectFrom(Vector<Integer> s, VectorMask<Integer> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract IntVector`
  `slice(int origin)`
  Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector.
  `abstract IntVector`
  `slice(int origin, Vector<Integer> 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 IntVector`
  `slice(int origin, Vector<Integer> w, VectorMask<Integer> 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 VectorSpecies<Integer>`
  `species()`
  Returns the species of this vector.
  `final IntVector`
  `sub(int e)`
  Subtracts an input scalar from this vector.
  `final IntVector`
  `sub(int e, VectorMask<Integer> m)`
  Subtracts an input scalar from this vector under the control of a mask.
  `final IntVector`
  `sub(Vector<Integer> v)`
  Subtracts a second input vector from this vector.
  `final IntVector`
  `sub(Vector<Integer> v, VectorMask<Integer> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `abstract VectorMask<Integer>`
  `test(VectorOperators.Test op)`
  Tests the lanes of this vector according to the given operation.
  `abstract VectorMask<Integer>`
  `test(VectorOperators.Test op, VectorMask<Integer> m)`
  Test selected lanes of this vector, according to the given operation.
  `final int[]`
  `toArray()`
  Returns an array of type `int[]` containing all the lane values.
  `final double[]`
  `toDoubleArray()`
  Returns a `double[]` array containing all the lane values, converted to the type `double`.
  `final int[]`
  `toIntArray()`
  Returns an `int[]` array containing all the lane values, converted to the type `int`.
  `final long[]`
  `toLongArray()`
  Returns a `long[]` array containing all the lane values, converted to the type `long`.
  `final String`
  `toString()`
  Returns a string representation of this vector, of the form `"[0,1,2...]"`, reporting the lane values of this vector, in lane order.
  `abstract IntVector`
  `unslice(int origin)`
  Reverses a slice(), inserting the current vector as a slice within a "background" input of zero lane values.
  `abstract IntVector`
  `unslice(int origin, Vector<Integer> 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 IntVector`
  `unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> 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 FloatVector`
  `viewAsFloatingLanes()`
  Views this vector as a vector of the same shape, length, and contents, but a lane type that is a floating-point type.
  `final IntVector`
  `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 IntVector`
  `withLane(int i, int e)`
  Replaces the lane element of this vector at lane index `i` with value `e`.
  `static IntVector`
  `zero(VectorSpecies<Integer> species)`
  Returns a vector of the given species where all lane elements are set to zero, the default primitive value.

  ### Methods declared in class jdk.incubator.vector.Vector

  `bitSize, byteSize, compare, elementSize, elementType, length, reduceLanesToLong, reduceLanesToLong, reinterpretShape, shape, toShuffle`

  ### Methods declared in class java.lang.Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- ## Field Details

  - ### SPECIES_64

    public static final VectorSpecies<Integer> SPECIES_64
    Species representing `IntVector`s of `VectorShape.S_64_BIT`.

  - ### SPECIES_128

    public static final VectorSpecies<Integer> SPECIES_128
    Species representing `IntVector`s of `VectorShape.S_128_BIT`.

  - ### SPECIES_256

    public static final VectorSpecies<Integer> SPECIES_256
    Species representing `IntVector`s of `VectorShape.S_256_BIT`.

  - ### SPECIES_512

    public static final VectorSpecies<Integer> SPECIES_512
    Species representing `IntVector`s of `VectorShape.S_512_BIT`.

  - ### SPECIES_MAX

    public static final VectorSpecies<Integer> SPECIES_MAX
    Species representing `IntVector`s of `VectorShape.S_Max_BIT`.

  - ### SPECIES_PREFERRED

    public static final VectorSpecies<Integer> SPECIES_PREFERRED
    Preferred species for `IntVector`s. A preferred species is a species of maximal bit-size for the platform.

- ## Method Details

  - ### zero

    public static IntVector zero(VectorSpecies<Integer> species)
    Returns a vector of the given species where all lane elements are set to zero, the default primitive value.
    Parameters:
      `species` - species of the desired zero vector
    Returns:
      a zero vector

  - ### broadcast

    public abstract IntVector broadcast(int e)
    Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`. The contents of the current vector are discarded; only the species is relevant to this operation.

    This method returns the value of this expression: `IntVector.broadcast(this.species(), e)`.

    API Note:
      Unlike the similar method named `broadcast()` in the supertype `Vector`, this method does not need to validate its argument, and cannot throw `IllegalArgumentException`. This method is therefore preferable to the supertype method.
    Parameters:
      `e` - the value to broadcast
    Returns:
      a vector where all lane elements are set to the primitive value `e`
    See Also:
      - `broadcast(VectorSpecies,long)`
      - `Vector.broadcast(long)`
      - `VectorSpecies.broadcast(long)`

  - ### broadcast

    public static 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`.
    Parameters:
      `species` - species of the desired vector
      `e` - the value to broadcast
    Returns:
      a vector where all lane elements are set to the primitive value `e`
    See Also:
      - `broadcast(long)`
      - `Vector.broadcast(long)`
      - `VectorSpecies.broadcast(long)`

  - ### broadcast

    public abstract IntVector broadcast(long e)
    Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`. The contents of the current vector are discarded; only the species is relevant to this operation.

    This method returns the value of this expression: `EVector.broadcast(this.species(), (ETYPE)e)`, where `EVector` is the vector class specific to this vector's element type `ETYPE`.

    The `long` value `e` must be accurately representable by the `ETYPE` of this vector's species, so that `e==(long)(ETYPE)e`. If this rule is violated the problem is not detected statically, but an `IllegalArgumentException` is thrown at run-time. Thus, this method somewhat weakens the static type checking of immediate constants and other scalars, but it makes up for this by improving the expressiveness of the generic API. Note that an `e` value in the range `[-128..127]` is always acceptable, since every `ETYPE` will accept every `byte` value.

    Specified by:
      `broadcast` in class `Vector<Integer>`
    API Note:
      When working with vector subtypes like `IntVector`, the more strongly typed method is typically selected. It can be explicitly selected using a cast: `v.broadcast((int)e)`. The two expressions will produce numerically identical results.
    Parameters:
      `e` - the value to broadcast
    Returns:
      a vector where all lane elements are set to the primitive value `e`
    See Also:
      - `VectorSpecies.broadcast(long)`
      - `broadcast(int)`
      - `FloatVector.broadcast(float)`

  - ### broadcast

    public static 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`. The `long` value must be accurately representable by the `ETYPE` of the vector species, so that `e==(long)(ETYPE)e`.
    Parameters:
      `species` - species of the desired vector
      `e` - the value to broadcast
    Returns:
      a vector where all lane elements are set to the primitive value `e`
    Throws:
      `IllegalArgumentException` - if the given `long` value cannot be represented by the vector's `ETYPE`
    See Also:
      - `broadcast(VectorSpecies,int)`
      - `VectorSpecies.checkValue(long)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Unary op)
    Operates on the lane values of this vector. This is a lane-wise unary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to process lane values
    Returns:
      the result of applying the operation lane-wise to the input vector
    See Also:
      - `VectorOperators.NEG`
      - `VectorOperators.NOT`
      - `VectorOperators.SIN`
      - `Vector.lanewise(VectorOperators.Unary,VectorMask)`
      - `Vector.lanewise(VectorOperators.Binary,Vector)`
      - `Vector.lanewise(VectorOperators.Ternary,Vector,Vector)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Unary op, VectorMask<Integer> m)
    Operates on the lane values of this vector, with selection of lane elements controlled by a mask. This is a lane-wise unary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to process lane values
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vector
    See Also:
      - `Vector.lanewise(VectorOperators.Unary)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v)
    Combines the corresponding lane values of this vector with those of a second input vector. This is a lane-wise binary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to combine lane values
      `v` - the input vector
    Returns:
      the result of applying the operation lane-wise to the two input vectors
    See Also:
      - `lanewise(VectorOperators.Binary,int)`
      - `lanewise(VectorOperators.Binary,int,VectorMask)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Binary op, Vector<Integer> v, VectorMask<Integer> 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. This is a lane-wise binary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to combine lane values
      `v` - the second input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the two input vectors
    See Also:
      - `lanewise(VectorOperators.Binary,int,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Binary op, int e)
    Combines the lane values of this vector with the value of a broadcast scalar. This is a lane-wise binary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e))`.
    Parameters:
      `op` - the operation used to process lane values
      `e` - the input scalar
    Returns:
      the result of applying the operation lane-wise to the two input vectors
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Binary op, int e, VectorMask<Integer> m)
    Combines the lane values of this vector with the value of a broadcast scalar, with selection of lane elements controlled by a mask. This is a masked lane-wise binary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e), m)`.
    Parameters:
      `op` - the operation used to process lane values
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vector and the scalar
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Binary,Vector,VectorMask)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Binary op, long e)
    Combines the lane values of this vector with the value of a broadcast scalar. This is a lane-wise binary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e))`.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    API Note:
      When working with vector subtypes like `IntVector`, the more strongly typed method is typically selected. It can be explicitly selected using a cast: `v.lanewise(op,(int)e)`. The two expressions will produce numerically identical results.
    Parameters:
      `op` - the operation used to combine lane values
      `e` - the input scalar
    Returns:
      the result of applying the operation lane-wise to the input vector and the scalar
    See Also:
      - `Vector.broadcast(long)`
      - `Vector.lanewise(VectorOperators.Binary,long,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Binary op, long e, VectorMask<Integer> 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. This is a lane-wise binary operation which applies the selected operation to each lane. The second operand is a broadcast integral value. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e), m)`.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    API Note:
      When working with vector subtypes like `IntVector`, the more strongly typed method is typically selected. It can be explicitly selected using a cast: `v.lanewise(op,(int)e,m)`. The two expressions will produce numerically identical results.
    Parameters:
      `op` - the operation used to combine lane values
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vector and the scalar
    See Also:
      - `Vector.broadcast(long)`
      - `Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2)
    Combines the corresponding lane values of this vector with the lanes of a second and a third input vector. This is a lane-wise ternary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to combine lane values
      `v1` - the second input vector
      `v2` - the third input vector
    Returns:
      the result of applying the operation lane-wise to the three input vectors
    See Also:
      - `lanewise(VectorOperators.Ternary,int,int,VectorMask)`
      - `lanewise(VectorOperators.Ternary,Vector,int,VectorMask)`
      - `lanewise(VectorOperators.Ternary,int,Vector,VectorMask)`
      - `lanewise(VectorOperators.Ternary,int,int)`
      - `lanewise(VectorOperators.Ternary,Vector,int)`
      - `lanewise(VectorOperators.Ternary,int,Vector)`

  - ### lanewise

    public abstract IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, Vector<Integer> v2, VectorMask<Integer> 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. This is a lane-wise ternary operation which applies the selected operation to each lane.
    Specified by:
      `lanewise` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to combine lane values
      `v1` - the second input vector
      `v2` - the third input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the three input vectors
    See Also:
      - `lanewise(VectorOperators.Ternary,int,int,VectorMask)`
      - `lanewise(VectorOperators.Ternary,Vector,int,VectorMask)`
      - `lanewise(VectorOperators.Ternary,int,Vector,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2)
    Combines the lane values of this vector with the values of two broadcast scalars. This is a lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e1), this.broadcast(e2))`.
    Parameters:
      `op` - the operation used to combine lane values
      `e1` - the first input scalar
      `e2` - the second input scalar
    Returns:
      the result of applying the operation lane-wise to the input vector and the scalars
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,Vector,Vector)`
      - `lanewise(VectorOperators.Ternary,int,int,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, int e1, int e2, VectorMask<Integer> m)
    Combines the lane values of this vector with the values of two broadcast scalars, with selection of lane elements controlled by a mask. This is a masked lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e1), this.broadcast(e2), m)`.
    Parameters:
      `op` - the operation used to combine lane values
      `e1` - the first input scalar
      `e2` - the second input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vector and the scalars
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)`
      - `lanewise(VectorOperators.Ternary,int,int)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2)
    Combines the lane values of this vector with the values of another vector and a broadcast scalar. This is a lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, v1, this.broadcast(e2))`.
    Parameters:
      `op` - the operation used to combine lane values
      `v1` - the other input vector
      `e2` - the input scalar
    Returns:
      the result of applying the operation lane-wise to the input vectors and the scalar
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,int,int)`
      - `lanewise(VectorOperators.Ternary,Vector,int,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, Vector<Integer> v1, int e2, VectorMask<Integer> 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. This is a masked lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, v1, this.broadcast(e2), m)`.
    Parameters:
      `op` - the operation used to combine lane values
      `v1` - the other input vector
      `e2` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vectors and the scalar
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,Vector,Vector)`
      - `lanewise(VectorOperators.Ternary,int,int,VectorMask)`
      - `lanewise(VectorOperators.Ternary,Vector,int)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2)
    Combines the lane values of this vector with the values of another vector and a broadcast scalar. This is a lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e1), v2)`.
    Parameters:
      `op` - the operation used to combine lane values
      `e1` - the input scalar
      `v2` - the other input vector
    Returns:
      the result of applying the operation lane-wise to the input vectors and the scalar
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,Vector,Vector)`
      - `lanewise(VectorOperators.Ternary,int,Vector,VectorMask)`

  - ### lanewise

    public final IntVector lanewise(VectorOperators.Ternary op, int e1, Vector<Integer> v2, VectorMask<Integer> 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. This is a masked lane-wise ternary operation which applies the selected operation to each lane. The return value will be equal to this expression: `this.lanewise(op, this.broadcast(e1), v2, m)`.
    Parameters:
      `op` - the operation used to combine lane values
      `e1` - the input scalar
      `v2` - the other input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of applying the operation lane-wise to the input vectors and the scalar
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)`
      - `lanewise(VectorOperators.Ternary,int,Vector)`

  - ### add

    public final IntVector add(Vector<Integer> v)
    Adds this vector to a second input vector. This is a lane-wise binary operation which applies the primitive addition operation (`+`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``ADD``, v)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `add` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the result of adding this vector to the second input vector
    See Also:
      - `add(int)`

  - ### add

    public final IntVector add(int e)
    Adds this vector to the broadcast of an input scalar. This is a lane-wise binary operation which applies the primitive addition operation (`+`) to each lane. This method is also equivalent to the expression `lanewise``(``ADD``, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of adding each lane of this vector to the scalar
    See Also:
      - `add(Vector)`
      - `broadcast(int)`
      - `add(int,VectorMask)`
      - `VectorOperators.ADD`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### add

    public final IntVector add(Vector<Integer> v, VectorMask<Integer> m)
    Adds this vector to a second input vector, selecting lanes under the control of a mask. This is a masked lane-wise binary operation which applies the primitive addition operation (`+`) to each pair of corresponding lane values. For any lane unset in the mask, the primitive operation is suppressed and this vector retains the original value stored in that lane. This method is also equivalent to the expression `lanewise``(``ADD``, v, m)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `add` in class `Vector<Integer>`
    Parameters:
      `v` - the second input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of adding this vector to the given vector
    See Also:
      - `add(int,VectorMask)`

  - ### add

    public final IntVector add(int e, VectorMask<Integer> m)
    Adds this vector to the broadcast of an input scalar, selecting lane elements controlled by a mask. This is a masked lane-wise binary operation which applies the primitive addition operation (`+`) to each lane. This method is also equivalent to the expression `lanewise``(``ADD``, s, m)`.
    Parameters:
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of adding each lane of this vector to the scalar
    See Also:
      - `add(Vector,VectorMask)`
      - `broadcast(int)`
      - `add(int)`
      - `VectorOperators.ADD`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### sub

    public final IntVector sub(Vector<Integer> v)
    Subtracts a second input vector from this vector. This is a lane-wise binary operation which applies the primitive subtraction operation (`-`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``SUB``, v)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `sub` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the result of subtracting the second input vector from this vector
    See Also:
      - `sub(int)`

  - ### sub

    public final IntVector sub(int e)
    Subtracts an input scalar from this vector. This is a masked lane-wise binary operation which applies the primitive subtraction operation (`-`) to each lane. This method is also equivalent to the expression `lanewise``(``SUB``, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of subtracting the scalar from each lane of this vector
    See Also:
      - `sub(Vector)`
      - `broadcast(int)`
      - `sub(int,VectorMask)`
      - `VectorOperators.SUB`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### sub

    public final IntVector sub(Vector<Integer> v, VectorMask<Integer> m)
    Subtracts a second input vector from this vector under the control of a mask. This is a masked lane-wise binary operation which applies the primitive subtraction operation (`-`) to each pair of corresponding lane values. For any lane unset in the mask, the primitive operation is suppressed and this vector retains the original value stored in that lane. This method is also equivalent to the expression `lanewise``(``SUB``, v, m)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `sub` in class `Vector<Integer>`
    Parameters:
      `v` - the second input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of subtracting the second input vector from this vector
    See Also:
      - `sub(int,VectorMask)`

  - ### sub

    public final IntVector sub(int e, VectorMask<Integer> m)
    Subtracts an input scalar from this vector under the control of a mask. This is a masked lane-wise binary operation which applies the primitive subtraction operation (`-`) to each lane. This method is also equivalent to the expression `lanewise``(``SUB``, s, m)`.
    Parameters:
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of subtracting the scalar from each lane of this vector
    See Also:
      - `sub(Vector,VectorMask)`
      - `broadcast(int)`
      - `sub(int)`
      - `VectorOperators.SUB`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### mul

    public final IntVector mul(Vector<Integer> v)
    Multiplies this vector by a second input vector. This is a lane-wise binary operation which applies the primitive multiplication operation (`*`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``MUL``, v)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `mul` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the result of multiplying this vector by the second input vector
    See Also:
      - `mul(int)`

  - ### mul

    public final IntVector mul(int e)
    Multiplies this vector by the broadcast of an input scalar. This is a lane-wise binary operation which applies the primitive multiplication operation (`*`) to each lane. This method is also equivalent to the expression `lanewise``(``MUL``, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of multiplying this vector by the given scalar
    See Also:
      - `mul(Vector)`
      - `broadcast(int)`
      - `mul(int,VectorMask)`
      - `VectorOperators.MUL`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### mul

    public final IntVector mul(Vector<Integer> v, VectorMask<Integer> m)
    Multiplies this vector by a second input vector under the control of a mask. This is a lane-wise binary operation which applies the primitive multiplication operation (`*`) to each pair of corresponding lane values. For any lane unset in the mask, the primitive operation is suppressed and this vector retains the original value stored in that lane. This method is also equivalent to the expression `lanewise``(``MUL``, v, m)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `mul` in class `Vector<Integer>`
    Parameters:
      `v` - the second input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of multiplying this vector by the given vector
    See Also:
      - `mul(int,VectorMask)`

  - ### mul

    public final IntVector mul(int e, VectorMask<Integer> m)
    Multiplies this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask. This is a masked lane-wise binary operation which applies the primitive multiplication operation (`*`) to each lane. This method is also equivalent to the expression `lanewise``(``MUL``, s, m)`.
    Parameters:
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of muling each lane of this vector to the scalar
    See Also:
      - `mul(Vector,VectorMask)`
      - `broadcast(int)`
      - `mul(int)`
      - `VectorOperators.MUL`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### div

    public final IntVector div(Vector<Integer> v)
    Divides this vector by a second input vector. This is a lane-wise binary operation which applies the primitive division operation (`/`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``DIV``, v)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `div` in class `Vector<Integer>`
    API Note:
      If there is a zero divisor, `ArithmeticException` will be thrown.
    Parameters:
      `v` - a second input vector
    Returns:
      the result of dividing this vector by the second input vector
    See Also:
      - `Vector.div(Vector,VectorMask)`
      - `DoubleVector.div(double)`
      - `VectorOperators.DIV`
      - `Vector.lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### div

    public final IntVector div(int e)
    Divides this vector by the broadcast of an input scalar. This is a lane-wise binary operation which applies the primitive division operation (`/`) to each lane. This method is also equivalent to the expression `lanewise``(``DIV``, e)`.
    API Note:
      If there is a zero divisor, `ArithmeticException` will be thrown.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of dividing each lane of this vector by the scalar
    See Also:
      - `div(Vector)`
      - `broadcast(int)`
      - `div(int,VectorMask)`
      - `VectorOperators.DIV`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### div

    public final IntVector div(Vector<Integer> v, VectorMask<Integer> m)
    Divides this vector by a second input vector under the control of a mask. This is a lane-wise binary operation which applies the primitive division operation (`/`) to each pair of corresponding lane values. For any lane unset in the mask, the primitive operation is suppressed and this vector retains the original value stored in that lane. This method is also equivalent to the expression `lanewise``(``DIV``, v, m)`.

    As a full-service named operation, this method comes in masked and unmasked overloadings, and (in subclasses) also comes in scalar-broadcast overloadings (both masked and unmasked).

    Specified by:
      `div` in class `Vector<Integer>`
    API Note:
      If there is a zero divisor, `ArithmeticException` will be thrown.
    Parameters:
      `v` - a second input vector
      `m` - the mask controlling lane selection
    Returns:
      the result of dividing this vector by the second input vector
    See Also:
      - `div(int,VectorMask)`

  - ### div

    public final IntVector div(int e, VectorMask<Integer> m)
    Divides this vector by the broadcast of an input scalar, selecting lane elements controlled by a mask. This is a masked lane-wise binary operation which applies the primitive division operation (`/`) to each lane. This method is also equivalent to the expression `lanewise``(``DIV``, s, m)`.
    API Note:
      If there is a zero divisor, `ArithmeticException` will be thrown.
    Parameters:
      `e` - the input scalar
      `m` - the mask controlling lane selection
    Returns:
      the result of dividing each lane of this vector by the scalar
    See Also:
      - `div(Vector,VectorMask)`
      - `broadcast(int)`
      - `div(int)`
      - `VectorOperators.DIV`
      - `lanewise(VectorOperators.Binary,Vector)`
      - `lanewise(VectorOperators.Binary,int)`

  - ### min

    public final IntVector min(Vector<Integer> v)
    Computes the smaller of this vector and a second input vector. This is a lane-wise binary operation which applies the operation `Math.min()` to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``MIN``, v)`.
    Specified by:
      `min` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the lanewise minimum of this vector and the second input vector
    See Also:
      - `min(int)`
      - `VectorOperators.MIN`
      - `Vector.lanewise(VectorOperators.Binary,Vector)`
      - `Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### min

    public final IntVector min(int e)
    Computes the smaller of this vector and the broadcast of an input scalar. This is a lane-wise binary operation which applies the operation `Math.min()` to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``MIN``, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of multiplying this vector by the given scalar
    See Also:
      - `min(Vector)`
      - `broadcast(int)`
      - `VectorOperators.MIN`
      - `lanewise(VectorOperators.Binary,int,VectorMask)`

  - ### max

    public final IntVector max(Vector<Integer> v)
    Computes the larger of this vector and a second input vector. This is a lane-wise binary operation which applies the operation `Math.max()` to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``MAX``, v)`.

    This is not a full-service named operation like `add()`. A masked version of this operation is not directly available but may be obtained via the masked version of `lanewise`. Subclasses define an additional scalar-broadcast overloading of this method.

    Specified by:
      `max` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the lanewise maximum of this vector and the second input vector
    See Also:
      - `max(int)`
      - `VectorOperators.MAX`
      - `Vector.lanewise(VectorOperators.Binary,Vector)`
      - `Vector.lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### max

    public final IntVector max(int e)
    Computes the larger of this vector and the broadcast of an input scalar. This is a lane-wise binary operation which applies the operation `Math.max()` to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``MAX``, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result of multiplying this vector by the given scalar
    See Also:
      - `max(Vector)`
      - `broadcast(int)`
      - `VectorOperators.MAX`
      - `lanewise(VectorOperators.Binary,int,VectorMask)`

  - ### and

    public final IntVector and(Vector<Integer> v)
    Computes the bitwise logical conjunction (`&`) of this vector and a second input vector. This is a lane-wise binary operation which applies the the primitive bitwise "and" operation (`&`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``AND``, v)`.

    This is not a full-service named operation like `add`. A masked version of this operation is not directly available but may be obtained via the masked version of `lanewise`.

    Parameters:
      `v` - a second input vector
    Returns:
      the bitwise `&` of this vector and the second input vector
    See Also:
      - `and(int)`
      - `or(Vector)`
      - `not()`
      - `VectorOperators.AND`
      - `lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### and

    public final IntVector and(int e)
    Computes the bitwise logical conjunction (`&`) of this vector and a scalar. This is a lane-wise binary operation which applies the the primitive bitwise "and" operation (`&`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``AND``, e)`.
    Parameters:
      `e` - an input scalar
    Returns:
      the bitwise `&` of this vector and scalar
    See Also:
      - `and(Vector)`
      - `VectorOperators.AND`
      - `lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### or

    public final IntVector or(Vector<Integer> v)
    Computes the bitwise logical disjunction (`|`) of this vector and a second input vector. This is a lane-wise binary operation which applies the the primitive bitwise "or" operation (`|`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``AND``, v)`.

    This is not a full-service named operation like `add`. A masked version of this operation is not directly available but may be obtained via the masked version of `lanewise`.

    Parameters:
      `v` - a second input vector
    Returns:
      the bitwise `|` of this vector and the second input vector
    See Also:
      - `or(int)`
      - `and(Vector)`
      - `not()`
      - `VectorOperators.OR`
      - `lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### or

    public final IntVector or(int e)
    Computes the bitwise logical disjunction (`|`) of this vector and a scalar. This is a lane-wise binary operation which applies the the primitive bitwise "or" operation (`|`) to each pair of corresponding lane values. This method is also equivalent to the expression `lanewise``(``OR``, e)`.
    Parameters:
      `e` - an input scalar
    Returns:
      the bitwise `|` of this vector and scalar
    See Also:
      - `or(Vector)`
      - `VectorOperators.OR`
      - `lanewise(VectorOperators.Binary,Vector,VectorMask)`

  - ### neg

    public final IntVector neg()
    Negates this vector. This is a lane-wise unary operation which applies the primitive negation operation (`-x`) to each input lane. This method is also equivalent to the expression `lanewise``(``NEG``)`.
    Specified by:
      `neg` in class `Vector<Integer>`
    Returns:
      the negation of this vector
    See Also:
      - `VectorOperators.NEG`
      - `Vector.lanewise(VectorOperators.Unary)`
      - `Vector.lanewise(VectorOperators.Unary,VectorMask)`

  - ### abs

    public final IntVector abs()
    Returns the absolute value of this vector. This is a lane-wise unary operation which applies the method `Math.abs` to each input lane. This method is also equivalent to the expression `lanewise``(``ABS``)`.
    Specified by:
      `abs` in class `Vector<Integer>`
    Returns:
      the absolute value of this vector
    See Also:
      - `VectorOperators.ABS`
      - `Vector.lanewise(VectorOperators.Unary)`
      - `Vector.lanewise(VectorOperators.Unary,VectorMask)`

  - ### not

    public final IntVector not()
    Computes the bitwise logical complement (`~`) of this vector. This is a lane-wise binary operation which applies the the primitive bitwise "not" operation (`~`) to each lane value. This method is also equivalent to the expression `lanewise``(``NOT``)`.

    This is not a full-service named operation like `add`. A masked version of this operation is not directly available but may be obtained via the masked version of `lanewise`.

    Returns:
      the bitwise complement `~` of this vector
    See Also:
      - `and(Vector)`
      - `VectorOperators.NOT`
      - `lanewise(VectorOperators.Unary,VectorMask)`

  - ### eq

    public final VectorMask<Integer> eq(Vector<Integer> v)
    Tests if this vector is equal to another input vector. This is a lane-wise binary test operation which applies the primitive equals operation (`==`) to each pair of corresponding lane values. The result is the same as `compare(VectorOperators.EQ, v)`.
    Specified by:
      `eq` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the mask result of testing lane-wise if this vector equal to the second input vector
    See Also:
      - `Vector.compare(VectorOperators.Comparison,Vector)`
      - `VectorOperators.EQ`
      - `Vector.equals(java.lang.Object)`

  - ### eq

    public final VectorMask<Integer> eq(int e)
    Tests if this vector is equal to an input scalar. This is a lane-wise binary test operation which applies the primitive equals operation (`==`) to each lane. The result is the same as `compare(VectorOperators.Comparison.EQ, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the result mask of testing if this vector is equal to `e`
    See Also:
      - `compare(VectorOperators.Comparison,int)`

  - ### lt

    public final VectorMask<Integer> lt(Vector<Integer> v)
    Tests if this vector is less than another input vector. This is a lane-wise binary test operation which applies the primitive less-than operation (`<`) to each lane. The result is the same as `compare(VectorOperators.LT, v)`.
    Specified by:
      `lt` in class `Vector<Integer>`
    Parameters:
      `v` - a second input vector
    Returns:
      the mask result of testing lane-wise if this vector is less than the second input vector
    See Also:
      - `Vector.compare(VectorOperators.Comparison,Vector)`
      - `VectorOperators.LT`

  - ### lt

    public final VectorMask<Integer> lt(int e)
    Tests if this vector is less than an input scalar. This is a lane-wise binary test operation which applies the primitive less than operation (`<`) to each lane. The result is the same as `compare(VectorOperators.LT, e)`.
    Parameters:
      `e` - the input scalar
    Returns:
      the mask result of testing if this vector is less than the input scalar
    See Also:
      - `compare(VectorOperators.Comparison,int)`

  - ### test

    public abstract VectorMask<Integer> test(VectorOperators.Test op)
    Tests the lanes of this vector according to the given operation. This is a lane-wise unary test operation which applies the given test operation to each lane value.
    Specified by:
      `test` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to test lane values
    Returns:
      the mask result of testing the lanes of this vector, according to the selected test operator
    See Also:
      - `VectorOperators.Comparison`
      - `Vector.test(VectorOperators.Test, VectorMask)`
      - `Vector.compare(VectorOperators.Comparison, Vector)`

  - ### test

    public abstract VectorMask<Integer> test(VectorOperators.Test op, VectorMask<Integer> m)
    Test selected lanes of this vector, according to the given operation. This is a masked lane-wise unary test operation which applies the given test operation to each lane value. The returned result is equal to the expression `test(op).and(m)`.
    Specified by:
      `test` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to test lane values
      `m` - the mask controlling lane selection
    Returns:
      the mask result of testing the lanes of this vector, according to the selected test operator, and only in the lanes selected by the mask
    See Also:
      - `Vector.test(VectorOperators.Test)`

  - ### compare

    public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, Vector<Integer> v)
    Tests this vector by comparing it with another input vector, according to the given comparison operation. This is a lane-wise binary test operation which applies the given comparison operation to each pair of corresponding lane values.
    Specified by:
      `compare` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to compare lane values
      `v` - a second input vector
    Returns:
      the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator
    See Also:
      - `Vector.eq(Vector)`
      - `Vector.lt(Vector)`
      - `VectorOperators.Comparison`
      - `Vector.compare(VectorOperators.Comparison, Vector, VectorMask)`
      - `Vector.test(VectorOperators.Test)`

  - ### compare

    public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, int e)
    Tests this vector by comparing it with an input scalar, according to the given comparison operation. This is a lane-wise binary test operation which applies the comparison operation to each lane.

    The result is the same as `compare(op, broadcast(species(), e))`. That is, the scalar may be regarded as broadcast to a vector of the same species, and then compared against the original vector, using the selected comparison operation.

    Parameters:
      `op` - the operation used to compare lane values
      `e` - the input scalar
    Returns:
      the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator
    See Also:
      - `compare(VectorOperators.Comparison,Vector)`
      - `eq(int)`
      - `lt(int)`

  - ### compare

    public final VectorMask<Integer> compare(VectorOperators.Comparison op, int e, VectorMask<Integer> m)
    Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask. This is a masked lane-wise binary test operation which applies to each pair of corresponding lane values. The returned result is equal to the expression `compare(op,s).and(m)`.
    Parameters:
      `op` - the operation used to compare lane values
      `e` - the input scalar
      `m` - the mask controlling lane selection
    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
    See Also:
      - `Vector.compare(VectorOperators.Comparison,Vector,VectorMask)`

  - ### compare

    public abstract VectorMask<Integer> compare(VectorOperators.Comparison op, long e)
    Tests this vector by comparing it with an input scalar, according to the given comparison operation. This is a lane-wise binary test operation which applies the given comparison operation to each lane value, paired with the broadcast value.

    The result is the same as `this.compare(op, this.broadcast(e))`. That is, the scalar may be regarded as broadcast to a vector of the same species, and then compared against the original vector, using the selected comparison operation.

    Specified by:
      `compare` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to compare lane values
      `e` - the input scalar
    Returns:
      the mask result of testing lane-wise if this vector compares to the input, according to the selected comparison operator
    See Also:
      - `Vector.broadcast(long)`
      - `Vector.compare(VectorOperators.Comparison,Vector)`

  - ### compare

    public final VectorMask<Integer> compare(VectorOperators.Comparison op, long e, VectorMask<Integer> m)
    Tests this vector by comparing it with an input scalar, according to the given comparison operation, in lanes selected by a mask. This is a masked lane-wise binary test operation which applies the given comparison operation to each lane value, paired with the broadcast value. The returned result is equal to the expression `compare(op,e).and(m)`.
    Specified by:
      `compare` in class `Vector<Integer>`
    Parameters:
      `op` - the operation used to compare lane values
      `e` - the input scalar
      `m` - the mask controlling lane selection
    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
    See Also:
      - `Vector.broadcast(long)`
      - `Vector.compare(VectorOperators.Comparison,Vector)`

  - ### blend

    public abstract IntVector blend(Vector<Integer> v, VectorMask<Integer> m)
    Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask. This is a masked lane-wise binary operation which selects each lane value from one or the other input.
    - For any lane set in the mask, the new lane value is taken from the second input vector, and replaces whatever value was in the that lane of this vector.
    - For any lane unset in the mask, the replacement is suppressed and this vector retains the original value stored in that lane.
    The following pseudocode illustrates this behavior:

         Vector<E> a = ...;
         VectorSpecies<E> species = a.species();
         Vector<E> b = ...;
         b.check(species);
         VectorMask<E> m = ...;
         ETYPE[] ar = a.toArray();
         for (int i = 0; i < ar.length; i++) {
             if (m.laneIsSet(i)) {
                 ar[i] = b.lane(i);
             }
         }
         return EVector.fromArray(s, ar, 0);

    Specified by:
      `blend` in class `Vector<Integer>`
    Parameters:
      `v` - the second input vector, containing replacement lane values
      `m` - the mask controlling lane selection from the second input vector
    Returns:
      the result of blending the lane elements of this vector with those of the second input vector

  - ### addIndex

    public abstract IntVector addIndex(int scale)
    Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant. This is a lane-wise unary operation which, for each lane `N`, computes the scaled index value `N*scale` and adds it to the value already in lane `N` of the current vector.

    The scale must not be so large, and the element size must not be so small, that that there would be an overflow when computing any of the `N*scale` or `VLENGTH*scale`, when the result is represented using the vector lane type `ETYPE`.

    The following pseudocode illustrates this behavior:

         Vector<E> a = ...;
         VectorSpecies<E> species = a.species();
         ETYPE[] ar = a.toArray();
         for (int i = 0; i < ar.length; i++) {
             long d = (long)i * scale;
             if (d != (ETYPE) d)  throw ...;
             ar[i] += (ETYPE) d;
         }
         long d = (long)ar.length * scale;
         if (d != (ETYPE) d)  throw ...;
         return EVector.fromArray(s, ar, 0);

    Specified by:
      `addIndex` in class `Vector<Integer>`
    Parameters:
      `scale` - the number to multiply by each lane index `N`, typically `1`
    Returns:
      the result of incrementing each lane element by its corresponding lane index `N`, scaled by `scale`

  - ### blend

    public final IntVector blend(int e, VectorMask<Integer> m)
    Replaces selected lanes of this vector with a scalar value under the control of a mask. This is a masked lane-wise binary operation which selects each lane value from one or the other input. The returned result is equal to the expression `blend(broadcast(e),m)`.
    Parameters:
      `e` - the input scalar, containing the replacement lane value
      `m` - the mask controlling lane selection of the scalar
    Returns:
      the result of blending the lane elements of this vector with the scalar value

  - ### blend

    public final IntVector blend(long e, VectorMask<Integer> m)
    Replaces selected lanes of this vector with a scalar value under the control of a mask. This is a masked lane-wise binary operation which selects each lane value from one or the other input. The returned result is equal to the expression `blend(broadcast(e),m)`.
    Specified by:
      `blend` in class `Vector<Integer>`
    Parameters:
      `e` - the input scalar, containing the replacement lane value
      `m` - the mask controlling lane selection of the scalar
    Returns:
      the result of blending the lane elements of this vector with the scalar value

  - ### slice

    public abstract IntVector slice(int origin, Vector<Integer> 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. The block of `VLENGTH` lanes is extracted into its own vector and returned.

    This is a cross-lane operation that shifts lane elements to the front, from the current vector and the second vector. Both vectors can be viewed as a combined "background" of length `2*VLENGTH`, from which a slice is extracted. The lane numbered `N` in the output vector is copied from lane `origin+N` of the input vector, if that lane exists, else from lane `origin+N-VLENGTH` of the second vector (which is guaranteed to exist).

    The `origin` value must be in the inclusive range `0..VLENGTH`. As limiting cases, `v.slice(0,w)` and `v.slice(VLENGTH,w)` return `v` and `w`, respectively.

    Parameters:
      `origin` - the first input lane to transfer into the slice
      `v1` - a second vector logically concatenated with the first, before the slice is taken (if omitted it defaults to zero)
    Returns:
      a contiguous slice of `VLENGTH` lanes, taken from this vector starting at the indicated origin, and continuing (as needed) into the second vector
    See Also:
      - `Vector.slice(int,Vector,VectorMask)`
      - `Vector.slice(int)`
      - `Vector.unslice(int,Vector,int)`

  - ### slice

    public final IntVector slice(int origin, Vector<Integer> w, VectorMask<Integer> 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. The block of `VLENGTH` lanes is extracted into its own vector and returned. The resulting vector will be zero in all lanes unset in the given mask. Lanes set in the mask will contain data copied from selected lanes of `this` or `v1`.

    This is a cross-lane operation that shifts lane elements to the front, from the current vector and the second vector. Both vectors can be viewed as a combined "background" of length `2*VLENGTH`, from which a slice is extracted. The returned result is equal to the expression `broadcast(0).blend(slice(origin,v1),m)`.

    Specified by:
      `slice` in class `Vector<Integer>`
    Parameters:
      `origin` - the first input lane to transfer into the slice
      `w` - a second vector logically concatenated with the first, before the slice is taken (if omitted it defaults to zero)
      `m` - the mask controlling lane selection into the resulting vector
    Returns:
      a contiguous slice of `VLENGTH` lanes, taken from this vector starting at the indicated origin, and continuing (as needed) into the second vector
    See Also:
      - `Vector.slice(int,Vector)`
      - `Vector.unslice(int,Vector,int,VectorMask)`

  - ### slice

    public abstract IntVector slice(int origin)
    Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector. A block of `VLENGTH` lanes, possibly padded with zero lanes, is extracted into its own vector and returned. This is a convenience method which slices from a single vector against an extended background of zero lanes. It is equivalent to `slice``(origin,` `broadcast``(0))`. It may also be viewed simply as a cross-lane shift from later to earlier lanes, with zeroes filling in the vacated lanes at the end of the vector. In this view, the shift count is `origin`.
    Parameters:
      `origin` - the first input lane to transfer into the slice
    Returns:
      the last `VLENGTH-origin` input lanes, placed starting in the first lane of the output, padded at the end with zeroes
    See Also:
      - `Vector.slice(int,Vector)`
      - `Vector.unslice(int,Vector,int)`

  - ### unslice

    public abstract IntVector unslice(int origin, Vector<Integer> 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.

    This is a cross-lane operation that permutes the lane elements of the current vector toward the back and inserts them into a logical pair of background vectors. Only one of the pair will be returned, however. The background is formed by duplicating the second input vector. (However, the output will never contain two duplicates from the same input lane.) The lane numbered `N` in the input vector is copied into lane `origin+N` of the first background vector, if that lane exists, else into lane `origin+N-VLENGTH` of the second background vector (which is guaranteed to exist). The first or second background vector, updated with the inserted slice, is returned. The `part` number of zero or one selects the first or second updated background vector.

    The `origin` value must be in the inclusive range `0..VLENGTH`. As limiting cases, `v.unslice(0,w,0)` and `v.unslice(VLENGTH,w,1)` both return `v`, while `v.unslice(0,w,1)` and `v.unslice(VLENGTH,w,0)` both return `w`.

    Specified by:
      `unslice` in class `Vector<Integer>`
    Parameters:
      `origin` - the first output lane to receive the slice
      `w` - the background vector that (as two copies) will receive the inserted slice
      `part` - the part number of the result (either zero or one)
    Returns:
      either the first or second part of a pair of background vectors `w`, updated by inserting this vector at the indicated origin
    See Also:
      - `Vector.slice(int,Vector)`
      - `Vector.unslice(int,Vector,int,VectorMask)`

  - ### unslice

    public abstract IntVector unslice(int origin, Vector<Integer> w, int part, VectorMask<Integer> 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.

    This is a cross-lane operation that permutes the lane elements of the current vector forward and inserts its lanes (when selected by the mask) into a logical pair of background vectors. As with the unmasked version of this method, only one of the pair will be returned, as selected by the `part` number. For each lane `N` selected by the mask, the lane value is copied into lane `origin+N` of the first background vector, if that lane exists, else into lane `origin+N-VLENGTH` of the second background vector (which is guaranteed to exist). Background lanes retain their original values if the corresponding input lanes `N` are unset in the mask. The first or second background vector, updated with set lanes of the inserted slice, is returned. The `part` number of zero or one selects the first or second updated background vector.

    Specified by:
      `unslice` in class `Vector<Integer>`
    Parameters:
      `origin` - the first output lane to receive the slice
      `w` - the background vector that (as two copies) will receive the inserted slice, if they are set in `m`
      `part` - the part number of the result (either zero or one)
      `m` - the mask controlling lane selection from the current vector
    Returns:
      either the first or second part of a pair of background vectors `w`, updated by inserting selected lanes of this vector at the indicated origin
    See Also:
      - `Vector.unslice(int,Vector,int)`
      - `Vector.slice(int,Vector)`

  - ### unslice

    public abstract IntVector unslice(int origin)
    Reverses a slice(), inserting the current vector as a slice within a "background" input of zero lane values. Compared to other `unslice()` methods, this method only returns the first of the pair of background vectors. This is a convenience method which returns the result of `unslice``(origin,` `broadcast``(0), 0)`. It may also be viewed simply as a cross-lane shift from earlier to later lanes, with zeroes filling in the vacated lanes at the beginning of the vector. In this view, the shift count is `origin`.
    Specified by:
      `unslice` in class `Vector<Integer>`
    Parameters:
      `origin` - the first output lane to receive the slice
    Returns:
      the first `VLENGTH-origin` input lanes, placed starting at the given origin, padded at the beginning with zeroes
    See Also:
      - `Vector.unslice(int,Vector,int)`
      - `Vector.slice(int)`

  - ### rearrange

    public abstract IntVector rearrange(VectorShuffle<Integer> m)
    Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle. This is a cross-lane operation that rearranges the lane elements of this vector. For each lane `N` of the shuffle, and for each lane source index `I=s.laneSource(N)` in the shuffle, the output lane `N` obtains the value from the input vector at lane `I`.
    Specified by:
      `rearrange` in class `Vector<Integer>`
    Parameters:
      `m` - the shuffle controlling lane index selection
    Returns:
      the rearrangement of the lane elements of this vector
    See Also:
      - `Vector.rearrange(VectorShuffle,VectorMask)`
      - `Vector.rearrange(VectorShuffle,Vector)`
      - `VectorShuffle.laneIsValid()`

  - ### rearrange

    public abstract IntVector rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)
    Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask. This is a cross-lane operation that rearranges the lane elements of this vector. For each lane `N` of the shuffle, and for each lane source index `I=s.laneSource(N)` in the shuffle, the output lane `N` obtains the value from the input vector at lane `I` if the mask is set. Otherwise the output lane `N` is set to zero.

    This method returns the value of this pseudocode:

         Vector<E> r = this.rearrange(s.wrapIndexes());
         VectorMask<E> valid = s.laneIsValid();
         if (m.andNot(valid).anyTrue()) throw ...;
         return broadcast(0).blend(r, m);

    Specified by:
      `rearrange` in class `Vector<Integer>`
    Parameters:
      `s` - the shuffle controlling lane index selection
      `m` - the mask controlling application of the shuffle
    Returns:
      the rearrangement of the lane elements of this vector
    See Also:
      - `Vector.rearrange(VectorShuffle)`
      - `Vector.rearrange(VectorShuffle,Vector)`
      - `VectorShuffle.laneIsValid()`

  - ### rearrange

    public abstract IntVector rearrange(VectorShuffle<Integer> s, Vector<Integer> 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. This is a cross-lane operation that rearranges the lane elements of the two input vectors (the current vector and a second vector `v`). For each lane `N` of the shuffle, and for each lane source index `I=s.laneSource(N)` in the shuffle, the output lane `N` obtains the value from the first vector at lane `I` if `I>=0`. Otherwise, the exceptional index `I` is wrapped by adding `VLENGTH` to it and used to index the second vector, at index `I+VLENGTH`.

    This method returns the value of this pseudocode:

         Vector<E> r1 = this.rearrange(s.wrapIndexes());
         // or else: r1 = this.rearrange(s, s.laneIsValid());
         Vector<E> r2 = v.rearrange(s.wrapIndexes());
         return r2.blend(r1,s.laneIsValid());

    Specified by:
      `rearrange` in class `Vector<Integer>`
    Parameters:
      `s` - the shuffle controlling lane selection from both input vectors
      `v` - the second input vector
    Returns:
      the rearrangement of lane elements of this vector and a second input vector
    See Also:
      - `Vector.rearrange(VectorShuffle)`
      - `Vector.rearrange(VectorShuffle,VectorMask)`
      - `VectorShuffle.laneIsValid()`
      - `Vector.slice(int,Vector)`

  - ### compress

    public abstract IntVector compress(VectorMask<Integer> m)
    Compresses the lane elements of this vector selecting lanes under the control of a specific mask. This is a cross-lane operation that compresses the lane elements of this vector as selected by the specified mask. For each lane `N` of the mask, if the mask at lane `N` is set, the element at lane `N` of input vector is selected and stored into the output vector contiguously starting from the lane `0`. All the upper remaining lanes, if any, of the output vector are set to zero.
    Specified by:
      `compress` in class `Vector<Integer>`
    Parameters:
      `m` - the mask controlling the compression
    Returns:
      the compressed lane elements of this vector
    Since:
      19

  - ### expand

    public abstract IntVector expand(VectorMask<Integer> m)
    Expands the lane elements of this vector under the control of a specific mask. This is a cross-lane operation that expands the contiguous lane elements of this vector into lanes of an output vector as selected by the specified mask. For each lane `N` of the mask, if the mask at lane `N` is set, the next contiguous element of input vector starting from lane `0` is selected and stored into the output vector at lane `N`. All the remaining lanes, if any, of the output vector are set to zero.
    Specified by:
      `expand` in class `Vector<Integer>`
    Parameters:
      `m` - the mask controlling the compression
    Returns:
      the expanded lane elements of this vector
    Since:
      19

  - ### selectFrom

    public abstract IntVector selectFrom(Vector<Integer> v)
    Using index values stored in the lanes of this vector, assemble values stored in second vector `v`. The second vector thus serves as a table, whose elements are selected by indexes in the current vector. This is a cross-lane operation that rearranges the lane elements of the argument vector, under the control of this vector. For each lane `N` of this vector, and for each lane value `I=this.lane(N)` in this vector, the output lane `N` obtains the value from the argument vector at lane `I`. In this way, the result contains only values stored in the argument vector `v`, but presented in an order which depends on the index values in `this`. The result is the same as the expression `v.rearrange(this.toShuffle())`.
    Specified by:
      `selectFrom` in class `Vector<Integer>`
    Parameters:
      `v` - the vector supplying the result values
    Returns:
      the rearrangement of the lane elements of `v`
    See Also:
      - `Vector.rearrange(VectorShuffle)`

  - ### selectFrom

    public abstract IntVector selectFrom(Vector<Integer> s, VectorMask<Integer> m)
    Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask. Using index values stored in the lanes of this vector, assemble values stored in second vector `v`. The second vector thus serves as a table, whose elements are selected by indexes in the current vector. Lanes that are unset in the mask receive a zero rather than a value from the table. This is a cross-lane operation that rearranges the lane elements of the argument vector, under the control of this vector and the mask. The result is the same as the expression `v.rearrange(this.toShuffle(), m)`.
    Specified by:
      `selectFrom` in class `Vector<Integer>`
    Parameters:
      `s` - the vector supplying the result values
      `m` - the mask controlling selection from `v`
    Returns:
      the rearrangement of the lane elements of `v`
    See Also:
      - `Vector.selectFrom(Vector)`
      - `Vector.rearrange(VectorShuffle,VectorMask)`

  - ### bitwiseBlend

    public final IntVector bitwiseBlend(Vector<Integer> bits, Vector<Integer> mask)
    Blends together the bits of two vectors under the control of a third, which supplies mask bits. This is a lane-wise ternary operation which performs a bitwise blending operation `(a&~c)|(b&c)` to each lane. This method is also equivalent to the expression `lanewise``(``BITWISE_BLEND``, bits, mask)`.
    Parameters:
      `bits` - input bits to blend into the current vector
      `mask` - a bitwise mask to enable blending of the input bits
    Returns:
      the bitwise blend of the given bits into the current vector, under control of the bitwise mask
    See Also:
      - `bitwiseBlend(int,int)`
      - `bitwiseBlend(int,Vector)`
      - `bitwiseBlend(Vector,int)`
      - `VectorOperators.BITWISE_BLEND`
      - `lanewise(VectorOperators.Ternary,Vector,Vector,VectorMask)`

  - ### bitwiseBlend

    public final IntVector bitwiseBlend(int bits, int mask)
    Blends together the bits of a vector and a scalar under the control of another scalar, which supplies mask bits. This is a lane-wise ternary operation which performs a bitwise blending operation `(a&~c)|(b&c)` to each lane. This method is also equivalent to the expression `lanewise``(``BITWISE_BLEND``, bits, mask)`.
    Parameters:
      `bits` - input bits to blend into the current vector
      `mask` - a bitwise mask to enable blending of the input bits
    Returns:
      the bitwise blend of the given bits into the current vector, under control of the bitwise mask
    See Also:
      - `bitwiseBlend(Vector,Vector)`
      - `VectorOperators.BITWISE_BLEND`
      - `lanewise(VectorOperators.Ternary,int,int,VectorMask)`

  - ### bitwiseBlend

    public final IntVector bitwiseBlend(int bits, Vector<Integer> mask)
    Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits. This is a lane-wise ternary operation which performs a bitwise blending operation `(a&~c)|(b&c)` to each lane. This method is also equivalent to the expression `lanewise``(``BITWISE_BLEND``, bits, mask)`.
    Parameters:
      `bits` - input bits to blend into the current vector
      `mask` - a bitwise mask to enable blending of the input bits
    Returns:
      the bitwise blend of the given bits into the current vector, under control of the bitwise mask
    See Also:
      - `bitwiseBlend(Vector,Vector)`
      - `VectorOperators.BITWISE_BLEND`
      - `lanewise(VectorOperators.Ternary,int,Vector,VectorMask)`

  - ### bitwiseBlend

    public final IntVector bitwiseBlend(Vector<Integer> bits, int mask)
    Blends together the bits of two vectors under the control of a scalar, which supplies mask bits. This is a lane-wise ternary operation which performs a bitwise blending operation `(a&~c)|(b&c)` to each lane. This method is also equivalent to the expression `lanewise``(``BITWISE_BLEND``, bits, mask)`.
    Parameters:
      `bits` - input bits to blend into the current vector
      `mask` - a bitwise mask to enable blending of the input bits
    Returns:
      the bitwise blend of the given bits into the current vector, under control of the bitwise mask
    See Also:
      - `bitwiseBlend(Vector,Vector)`
      - `VectorOperators.BITWISE_BLEND`
      - `lanewise(VectorOperators.Ternary,Vector,int,VectorMask)`

  - ### reduceLanes

    public abstract int reduceLanes(VectorOperators.Associative op)
    Returns a value accumulated from all the lanes of this vector. This is an associative cross-lane reduction operation which applies the specified operation to all the lane elements.

    A few reduction operations do not support arbitrary reordering of their operands, yet are included here because of their usefulness.

    - In the case of `FIRST_NONZERO`, the reduction returns the value from the lowest-numbered non-zero lane.
    - All other reduction operations are fully commutative and associative. The implementation can choose any order of processing, yet it will always produce the same result.
    Parameters:
      `op` - the operation used to combine lane values
    Returns:
      the accumulated result
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `reduceLanes(VectorOperators.Associative,VectorMask)`
      - `add(Vector)`
      - `mul(Vector)`
      - `min(Vector)`
      - `max(Vector)`
      - `and(Vector)`
      - `or(Vector)`
      - `VectorOperators.XOR`
      - `VectorOperators.FIRST_NONZERO`

  - ### reduceLanes

    public abstract int reduceLanes(VectorOperators.Associative op, VectorMask<Integer> m)
    Returns a value accumulated from selected lanes of this vector, controlled by a mask. This is an associative cross-lane reduction operation which applies the specified operation to the selected lane elements.

    If no elements are selected, an operation-specific identity value is returned.

    - If the operation is `ADD`, `XOR`, `OR`, or `FIRST_NONZERO`, then the identity value is zero, the default `int` value.
    - If the operation is `MUL`, then the identity value is one.
    - If the operation is `AND`, then the identity value is minus one (all bits set).
    - If the operation is `MAX`, then the identity value is `Integer.MIN_VALUE`.
    - If the operation is `MIN`, then the identity value is `Integer.MAX_VALUE`.

    A few reduction operations do not support arbitrary reordering of their operands, yet are included here because of their usefulness.

    - In the case of `FIRST_NONZERO`, the reduction returns the value from the lowest-numbered non-zero lane.
    - All other reduction operations are fully commutative and associative. The implementation can choose any order of processing, yet it will always produce the same result.
    Parameters:
      `op` - the operation used to combine lane values
      `m` - the mask controlling lane selection
    Returns:
      the reduced result accumulated from the selected lane values
    Throws:
      `UnsupportedOperationException` - if this vector does not support the requested operation
    See Also:
      - `reduceLanes(VectorOperators.Associative)`

  - ### lane

    public abstract int lane(int i)
    Gets the lane element at lane index `i`
    Parameters:
      `i` - the lane index
    Returns:
      the lane element at lane index `i`
    Throws:
      `IllegalArgumentException` - if the index is is out of range (`< 0 || >= length()`)

  - ### withLane

    public abstract IntVector withLane(int i, int e)
    Replaces the lane element of this vector at lane index `i` with value `e`. This is a cross-lane operation and behaves as if it returns the result of blending this vector with an input vector that is the result of broadcasting `e` and a mask that has only one lane set at lane index `i`.
    Parameters:
      `i` - the lane index of the lane element to be replaced
      `e` - the value to be placed
    Returns:
      the result of replacing the lane element of this vector at lane index `i` with value `e`.
    Throws:
      `IllegalArgumentException` - if the index is is out of range (`< 0 || >= length()`)

  - ### toArray

    public final int[] toArray()
    Returns an array of type `int[]` containing all the lane values. The array length is the same as the vector length. The array elements are stored in lane order.

    This method behaves as if it stores this vector into an allocated array (using `intoArray`) and returns the array as follows:

           int[] a = new int[this.length()];
           this.intoArray(a, 0);
           return a;

    Specified by:
      `toArray` in class `Vector<Integer>`
    Returns:
      an array containing the lane values of this vector
    See Also:
      - `ByteVector.toArray()`
      - `toArray()`
      - `DoubleVector.toArray()`

  - ### toIntArray

    public final int[] toIntArray()
    Returns an `int[]` array containing all the lane values, converted to the type `int`. The array length is the same as the vector length. The array elements are converted as if by casting and stored in lane order. This operation may fail if the vector element type is `float` or `double`, when lanes contain fractional or out-of-range values. If any vector lane value is not representable as an `int`, an exception is thrown. This is an alias for `toArray()` When this method is used on used on vectors of type `IntVector`, there will be no loss of range or precision.
    Specified by:
      `toIntArray` in class `Vector<Integer>`
    Returns:
      an `int[]` array containing the lane values of this vector
    See Also:
      - `Vector.toArray()`
      - `Vector.toLongArray()`
      - `Vector.toDoubleArray()`
      - `toArray()`

  - ### toLongArray

    public final long[] toLongArray()
    Returns a `long[]` array containing all the lane values, converted to the type `long`. The array length is the same as the vector length. The array elements are converted as if by casting and stored in lane order. This operation may fail if the vector element type is `float` or `double`, when lanes contain fractional or out-of-range values. If any vector lane value is not representable as a `long`, an exception is thrown.
    Specified by:
      `toLongArray` in class `Vector<Integer>`
    Implementation Note:
      When this method is used on used on vectors of type `IntVector`, there will be no loss of precision or range, and so no `UnsupportedOperationException` will be thrown.
    Returns:
      a `long[]` array containing the lane values of this vector
    See Also:
      - `Vector.toArray()`
      - `Vector.toIntArray()`
      - `Vector.toDoubleArray()`
      - `LongVector.toArray()`

  - ### toDoubleArray

    public final double[] toDoubleArray()
    Returns a `double[]` array containing all the lane values, converted to the type `double`. The array length is the same as the vector length. The array elements are converted as if by casting and stored in lane order. This operation can lose precision if the vector element type is `long`.
    Specified by:
      `toDoubleArray` in class `Vector<Integer>`
    Implementation Note:
      When this method is used on used on vectors of type `IntVector`, there will be no loss of precision.
    Returns:
      a `double[]` array containing the lane values of this vector, possibly rounded to representable `double` values
    See Also:
      - `Vector.toArray()`
      - `Vector.toIntArray()`
      - `Vector.toLongArray()`
      - `DoubleVector.toArray()`

  - ### fromArray

    public static IntVector fromArray(VectorSpecies<Integer> species, int[] a, int offset)
    Loads a vector from an array of type `int[]` starting at an offset. For each vector lane, where `N` is the vector lane index, the array element at index `offset + N` is placed into the resulting vector at lane index `N`.
    Parameters:
      `species` - species of desired vector
      `a` - the array
      `offset` - the offset into the array
    Returns:
      the vector loaded from an array
    Throws:
      `IndexOutOfBoundsException` - if `offset+N < 0` or `offset+N >= a.length` for any lane `N` in the vector

  - ### fromArray

    public static 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. Lanes where the mask is unset are filled with the default value of `int` (zero). For each vector lane, where `N` is the vector lane index, if the mask lane at index `N` is set then the array element at index `offset + N` is placed into the resulting vector at lane index `N`, otherwise the default element value is placed into the resulting vector at lane index `N`.
    Parameters:
      `species` - species of desired vector
      `a` - the array
      `offset` - the offset into the array
      `m` - the mask controlling lane selection
    Returns:
      the vector loaded from an array
    Throws:
      `IndexOutOfBoundsException` - if `offset+N < 0` or `offset+N >= a.length` for any lane `N` in the vector where the mask is set

  - ### fromArray

    public static 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. The index map is a contiguous sequence of `VLENGTH` elements in a second array of `int`s, starting at a given `mapOffset`.

    For each vector lane, where `N` is the vector lane index, the lane is loaded from the array element `a[f(N)]`, where `f(N)` is the index mapping expression `offset + indexMap[mapOffset + N]]`.

    Parameters:
      `species` - species of desired vector
      `a` - the array
      `offset` - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
      `indexMap` - the index map
      `mapOffset` - the offset into the index map
    Returns:
      the vector loaded from the indexed elements of the array
    Throws:
      `IndexOutOfBoundsException` - if `mapOffset+N < 0` or if `mapOffset+N >= indexMap.length`, or if `f(N)=offset+indexMap[mapOffset+N]` is an invalid index into `a`, for any lane `N` in the vector
    See Also:
      - `toIntArray()`

  - ### fromArray

    public static 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. The index map is a contiguous sequence of `VLENGTH` elements in a second array of `int`s, starting at a given `mapOffset`.

    For each vector lane, where `N` is the vector lane index, if the lane is set in the mask, the lane is loaded from the array element `a[f(N)]`, where `f(N)` is the index mapping expression `offset + indexMap[mapOffset + N]]`. Unset lanes in the resulting vector are set to zero.

    Parameters:
      `species` - species of desired vector
      `a` - the array
      `offset` - the offset into the array, may be negative if relative indexes in the index map compensate to produce a value within the array bounds
      `indexMap` - the index map
      `mapOffset` - the offset into the index map
      `m` - the mask controlling lane selection
    Returns:
      the vector loaded from the indexed elements of the array
    Throws:
      `IndexOutOfBoundsException` - if `mapOffset+N < 0` or if `mapOffset+N >= indexMap.length`, or if `f(N)=offset+indexMap[mapOffset+N]` is an invalid index into `a`, for any lane `N` in the vector where the mask is set
    See Also:
      - `toIntArray()`

  - ### fromMemorySegment

    public static 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. Bytes are composed into primitive lane elements according to the specified byte order. The vector is arranged into lanes according to memory ordering.

    This method behaves as if it returns the result of calling `fromMemorySegment()`PREVIEW as follows:

         var m = species.maskAll(true);
         return fromMemorySegment(species, ms, offset, bo, m);

    Parameters:
      `species` - species of desired vector
      `ms` - the memory segment
      `offset` - the offset into the memory segment
      `bo` - the intended byte order
    Returns:
      a vector loaded from the memory segment
    Throws:
      `IndexOutOfBoundsException` - if `offset+N*4 < 0` or `offset+N*4 >= ms.byteSize()` for any lane `N` in the vector
      `IllegalArgumentException` - if the memory segment is a heap segment that is not backed by a `byte[]` array.
      `IllegalStateException` - if the memory segment's session is not alive, or if access occurs from a thread other than the thread owning the session.
    Since:
      19

  - ### fromMemorySegment

    public static 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. Lanes where the mask is unset are filled with the default value of `int` (zero). Bytes are composed into primitive lane elements according to the specified byte order. The vector is arranged into lanes according to memory ordering.

    The following pseudocode illustrates the behavior:

         var slice = ms.asSlice(offset);
         int[] ar = new int[species.length()];
         for (int n = 0; n < ar.length; n++) {
             if (m.laneIsSet(n)) {
                 ar[n] = slice.getAtIndex(ValuaLayout.JAVA_INT.withBitAlignment(8), n);
             }
         }
         IntVector r = IntVector.fromArray(species, ar, 0);

    Implementation Note:
      This operation is likely to be more efficient if the specified byte order is the same as the platform native order, since this method will not need to reorder the bytes of lane values.
    Parameters:
      `species` - species of desired vector
      `ms` - the memory segment
      `offset` - the offset into the memory segment
      `bo` - the intended byte order
      `m` - the mask controlling lane selection
    Returns:
      a vector loaded from the memory segment
    Throws:
      `IndexOutOfBoundsException` - if `offset+N*4 < 0` or `offset+N*4 >= ms.byteSize()` for any lane `N` in the vector where the mask is set
      `IllegalArgumentException` - if the memory segment is a heap segment that is not backed by a `byte[]` array.
      `IllegalStateException` - if the memory segment's session is not alive, or if access occurs from a thread other than the thread owning the session.
    Since:
      19

  - ### intoArray

    public final void intoArray(int[] a, int offset)
    Stores this vector into an array of type `int[]` starting at an offset.

    For each vector lane, where `N` is the vector lane index, the lane element at index `N` is stored into the array element `a[offset+N]`.

    Parameters:
      `a` - the array, of type `int[]`
      `offset` - the offset into the array
    Throws:
      `IndexOutOfBoundsException` - if `offset+N < 0` or `offset+N >= a.length` for any lane `N` in the vector

  - ### intoArray

    public final void intoArray(int[] a, int offset, VectorMask<Integer> m)
    Stores this vector into an array of type `int[]` starting at offset and using a mask.

    For each vector lane, where `N` is the vector lane index, the lane element at index `N` is stored into the array element `a[offset+N]`. If the mask lane at `N` is unset then the corresponding array element `a[offset+N]` is left unchanged.

    Array range checking is done for lanes where the mask is set. Lanes where the mask is unset are not stored and do not need to correspond to legitimate elements of `a`. That is, unset lanes may correspond to array indexes less than zero or beyond the end of the array.

    Parameters:
      `a` - the array, of type `int[]`
      `offset` - the offset into the array
      `m` - the mask controlling lane storage
    Throws:
      `IndexOutOfBoundsException` - if `offset+N < 0` or `offset+N >= a.length` for any lane `N` in the vector where the mask is set

  - ### intoArray

    public final void intoArray(int[] a, int offset, int[] indexMap, int mapOffset)
    Scatters this vector into an array of type `int[]` using indexes obtained by adding a fixed `offset` to a series of secondary offsets from an index map. The index map is a contiguous sequence of `VLENGTH` elements in a second array of `int`s, starting at a given `mapOffset`.

    For each vector lane, where `N` is the vector lane index, the lane element at index `N` is stored into the array element `a[f(N)]`, where `f(N)` is the index mapping expression `offset + indexMap[mapOffset + N]]`.

    Parameters:
      `a` - the array
      `offset` - an offset to combine with the index map offsets
      `indexMap` - the index map
      `mapOffset` - the offset into the index map
    Throws:
      `IndexOutOfBoundsException` - if `mapOffset+N < 0` or if `mapOffset+N >= indexMap.length`, or if `f(N)=offset+indexMap[mapOffset+N]` is an invalid index into `a`, for any lane `N` in the vector
    See Also:
      - `toIntArray()`

  - ### intoArray

    public final void intoArray(int[] a, int offset, int[] indexMap, int mapOffset, VectorMask<Integer> m)
    Scatters this vector into 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. The index map is a contiguous sequence of `VLENGTH` elements in a second array of `int`s, starting at a given `mapOffset`.

    For each vector lane, where `N` is the vector lane index, if the mask lane at index `N` is set then the lane element at index `N` is stored into the array element `a[f(N)]`, where `f(N)` is the index mapping expression `offset + indexMap[mapOffset + N]]`.

    Parameters:
      `a` - the array
      `offset` - an offset to combine with the index map offsets
      `indexMap` - the index map
      `mapOffset` - the offset into the index map
      `m` - the mask
    Throws:
      `IndexOutOfBoundsException` - if `mapOffset+N < 0` or if `mapOffset+N >= indexMap.length`, or if `f(N)=offset+indexMap[mapOffset+N]` is an invalid index into `a`, for any lane `N` in the vector where the mask is set
    See Also:
      - `toIntArray()`

  - ### intoMemorySegment

    public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)
    Stores this vector into a memory segmentPREVIEW starting at an offset using explicit byte order.

    Bytes are extracted from primitive lane elements according to the specified byte ordering. The lanes are stored according to their memory ordering.

    This method behaves as if it calls `intoMemorySegment()`PREVIEW as follows:

         var m = maskAll(true);
         intoMemorySegment(ms, offset, bo, m);

    Specified by:
      `intoMemorySegment` in class `Vector<Integer>`
    Parameters:
      `ms` - the memory segment
      `offset` - the offset into the memory segment
      `bo` - the intended byte order
    Since:
      19

  - ### intoMemorySegment

    public final void intoMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo, VectorMask<Integer> m)
    Stores this vector into a memory segmentPREVIEW starting at an offset using explicit byte order and a mask.

    Bytes are extracted from primitive lane elements according to the specified byte ordering. The lanes are stored according to their memory ordering.

    The following pseudocode illustrates the behavior, where `JAVA_E` is the layout of the primitive element type, `ETYPE` is the primitive element type, and `EVector` is the primitive vector type for this vector:

         ETYPE[] a = this.toArray();
         var slice = ms.asSlice(offset)
         for (int n = 0; n < a.length; n++) {
             if (m.laneIsSet(n)) {
                 slice.setAtIndex(ValueLayout.JAVA_E.withBitAlignment(8), n);
             }
         }

    Specified by:
      `intoMemorySegment` in class `Vector<Integer>`
    Parameters:
      `ms` - the memory segment
      `offset` - the offset into the memory segment
      `bo` - the intended byte order
      `m` - the mask controlling lane selection
    Since:
      19

  - ### reinterpretAsBytes

    public final 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. It is a convenience method for the expression `reinterpretShape(species().withLanes(byte.class))`. It may be considered an inverse to the various methods which consolidate bytes into larger lanes within the same vector, such as `Vector.reinterpretAsInts()`.
    Specified by:
      `reinterpretAsBytes` in class `Vector<Integer>`
    Returns:
      a `ByteVector` with the same shape and information content
    See Also:
      - `Vector.reinterpretShape(VectorSpecies,int)`
      - `intoMemorySegment(java.lang.foreign.MemorySegment, long, java.nio.ByteOrder)`PREVIEW
      - `FloatVector.intoMemorySegment(java.lang.foreign.MemorySegment, long, java.nio.ByteOrder)`PREVIEW
      - `VectorSpecies.withLanes(Class)`

  - ### viewAsIntegralLanes

    public final IntVector 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. This is a lane-wise reinterpretation cast on the lane values. As such, this method does not change `VSHAPE` or `VLENGTH`, and there is no change to the bitwise contents of the vector. If the vector's `ETYPE` is already an integral type, the same vector is returned unchanged. This method returns the value of this expression: `convert(conv,0)`, where `conv` is `VectorOperators.Conversion.ofReinterpret(E.class,F.class)`, and `F` is the non-floating-point type of the same size as `E`.
    Specified by:
      `viewAsIntegralLanes` in class `Vector<Integer>`
    Returns:
      the original vector, reinterpreted as non-floating point
    See Also:
      - `VectorOperators.Conversion.ofReinterpret(Class,Class)`
      - `Vector.convert(VectorOperators.Conversion,int)`

  - ### viewAsFloatingLanes

    public final FloatVector viewAsFloatingLanes()
    Views this vector as a vector of the same shape, length, and contents, but a lane type that is a floating-point type. This is a lane-wise reinterpretation cast on the lane values. As such, there this method does not change `VSHAPE` or `VLENGTH`, and there is no change to the bitwise contents of the vector. If the vector's `ETYPE` is already a float-point type, the same vector is returned unchanged. If the vector's element size does not match any floating point type size, an `IllegalArgumentException` is thrown. This method returns the value of this expression: `convert(conv,0)`, where `conv` is `VectorOperators.Conversion.ofReinterpret(E.class,F.class)`, and `F` is the floating-point type of the same size as `E`, if any.
    Specified by:
      `viewAsFloatingLanes` in class `Vector<Integer>`
    Returns:
      the original vector, reinterpreted as floating point
    See Also:
      - `VectorOperators.Conversion.ofReinterpret(Class,Class)`
      - `Vector.convert(VectorOperators.Conversion,int)`

  - ### toString

    public final String toString()
    Returns a string representation of this vector, of the form `"[0,1,2...]"`, reporting the lane values of this vector, in lane order. The string is produced as if by a call to `Arrays.toString()`, as appropriate to the `int` array returned by `this.toArray()`.
    Specified by:
      `toString` in class `Vector<Integer>`
    Returns:
      a string of the form `"[0,1,2...]"` reporting the lane values of this vector

  - ### equals

    public final boolean equals(Object obj)
    Indicates whether this vector is identical to some other object. Two vectors are identical only if they have the same species and same lane values, in the same order.

    The comparison of lane values is produced as if by a call to `Arrays.equals()`, as appropriate to the arrays returned by `toArray()` on both vectors.

    Specified by:
      `equals` in class `Vector<Integer>`
    Parameters:
      `obj` - the reference object with which to compare.
    Returns:
      whether this vector is identical to some other object
    See Also:
      - `Vector.eq(jdk.incubator.vector.Vector<E>)`

  - ### hashCode

    public final int hashCode()
    Returns a hash code value for the vector. based on the lane values and the vector species.
    Specified by:
      `hashCode` in class `Vector<Integer>`
    Returns:
      a hash code value for this vector
    See Also:
      - `Object.equals(java.lang.Object)`
      - `System.identityHashCode(java.lang.Object)`

  - ### species

    public final VectorSpecies<Integer> species()
    Description copied from class: `Vector`
    Returns the species of this vector.
    Specified by:
      `species` in class `Vector<E>`
    Returns:
      the species of this vector

  - ### check

    public final <F> Vector<F> check(VectorSpecies<F> species)
    Description copied from class: `Vector`
    Checks that this vector has the given species, and returns this vector unchanged. The effect is similar to this pseudocode: `species == species() ? this : throw new ClassCastException()`.
    Specified by:
      `check` in class `Vector<E>`
    Type Parameters:
      `F` - the boxed element type of the required species
    Parameters:
      `species` - the required species
    Returns:
      the same vector
    See Also:
      - `Vector.check(Class)`
      - `VectorMask.check(VectorSpecies)`
      - `VectorShuffle.check(VectorSpecies)`

  - ### check

    public final <F> Vector<F> check(Class<F> elementType)
    Checks that this vector has the given element type, and returns this vector unchanged. The effect is similar to this pseudocode: `elementType == species().elementType() ? this : throw new ClassCastException()`.
    Specified by:
      `check` in class `Vector<E>`
    Type Parameters:
      `F` - the boxed element type of the required lane type
    Parameters:
      `elementType` - the required lane type
    Returns:
      the same vector
    See Also:
      - `VectorSpecies.check(Class)`
      - `VectorMask.check(Class)`
      - `Vector.check(VectorSpecies)`
      - `VectorShuffle.check(VectorSpecies)`

  - ### maskAll

    public final VectorMask<Integer> maskAll(boolean bit)
    Returns a mask of same species as this vector, where each lane is set or unset according to given single boolean, which is broadcast to all lanes.

    This method returns the value of this expression: `species().maskAll(bit)`.

    Specified by:
      `maskAll` in class `Vector<E>`
    Parameters:
      `bit` - the given mask bit to be replicated
    Returns:
      a mask where each lane is set or unset according to the given bit
    See Also:
      - `VectorSpecies.maskAll(boolean)`

  - ### reinterpretAsShorts

    public ShortVector reinterpretAsShorts()
    Reinterprets this vector as a vector of the same shape and contents but a lane type of `short`, where the lanes are assembled from successive bytes according to little-endian order. It is a convenience method for the expression `reinterpretShape(species().withLanes(short.class))`. It may be considered an inverse to `Vector.reinterpretAsBytes()`.
    Specified by:
      `reinterpretAsShorts` in class `Vector<E>`
    Returns:
      a `ShortVector` with the same shape and information content

  - ### reinterpretAsInts

    public IntVector reinterpretAsInts()
    Reinterprets this vector as a vector of the same shape and contents but a lane type of `int`, where the lanes are assembled from successive bytes according to little-endian order. It is a convenience method for the expression `reinterpretShape(species().withLanes(int.class))`. It may be considered an inverse to `Vector.reinterpretAsBytes()`.
    Specified by:
      `reinterpretAsInts` in class `Vector<E>`
    Returns:
      a `IntVector` with the same shape and information content

  - ### reinterpretAsLongs

    public LongVector reinterpretAsLongs()
    Reinterprets this vector as a vector of the same shape and contents but a lane type of `long`, where the lanes are assembled from successive bytes according to little-endian order. It is a convenience method for the expression `reinterpretShape(species().withLanes(long.class))`. It may be considered an inverse to `Vector.reinterpretAsBytes()`.
    Specified by:
      `reinterpretAsLongs` in class `Vector<E>`
    Returns:
      a `LongVector` with the same shape and information content

  - ### reinterpretAsFloats

    public FloatVector reinterpretAsFloats()
    Reinterprets this vector as a vector of the same shape and contents but a lane type of `float`, where the lanes are assembled from successive bytes according to little-endian order. It is a convenience method for the expression `reinterpretShape(species().withLanes(float.class))`. It may be considered an inverse to `Vector.reinterpretAsBytes()`.
    Specified by:
      `reinterpretAsFloats` in class `Vector<E>`
    Returns:
      a `FloatVector` with the same shape and information content

  - ### reinterpretAsDoubles

    public DoubleVector reinterpretAsDoubles()
    Reinterprets this vector as a vector of the same shape and contents but a lane type of `double`, where the lanes are assembled from successive bytes according to little-endian order. It is a convenience method for the expression `reinterpretShape(species().withLanes(double.class))`. It may be considered an inverse to `Vector.reinterpretAsBytes()`.
    Specified by:
      `reinterpretAsDoubles` in class `Vector<E>`
    Returns:
      a `DoubleVector` with the same shape and information content

  - ### convert

    public final <F> Vector<F> convert(VectorOperators.Conversion<Integer,F> conv, int part)
    Convert this vector to a vector of the same shape and a new element type, converting lane values from the current `ETYPE` to a new lane type (called `FTYPE` here) according to the indicated conversion. This is a lane-wise shape-invariant operation which copies `ETYPE` values from the input vector to corresponding `FTYPE` values in the result. Depending on the selected conversion, this operation may either expand or contract its logical result, in which case a non-zero `part` number can further control the selection and steering of the logical result into the physical output vector.

    Each specific conversion is described by a conversion constant in the class `VectorOperators`. Each conversion operator has a specified domain type and range type. The domain type must exactly match the lane type of the input vector, while the range type determines the lane type of the output vectors.

    A conversion operator may be classified as (respectively) in-place, expanding, or contracting, depending on whether the bit-size of its domain type is (respectively) equal, less than, or greater than the bit-size of its range type.

    Independently, conversion operations can also be classified as reinterpreting or value-transforming, depending on whether the conversion copies representation bits unchanged, or changes the representation bits in order to retain (part or all of) the logical value of the input value.

    If a reinterpreting conversion contracts, it will truncate the upper bits of the input. If it expands, it will pad upper bits of the output with zero bits, when there are no corresponding input bits.

    An expanding conversion such as `S2I` (`short` value to `int`) takes a scalar value and represents it in a larger format (always with some information redundancy). A contracting conversion such as `D2F` (`double` value to `float`) takes a scalar value and represents it in a smaller format (always with some information loss). Some in-place conversions may also include information loss, such as `L2D` (`long` value to `double`) or `F2I` (`float` value to `int`). Reinterpreting in-place conversions are not lossy, unless the bitwise value is somehow not legal in the output type. Converting the bit-pattern of a `NaN` may discard bits from the `NaN`'s significand.

    This classification is important, because, unless otherwise documented, conversion operations never change vector shape, regardless of how they may change lane sizes. Therefore an expanding conversion cannot store all of its results in its output vector, because the output vector has fewer lanes of larger size, in order to have the same overall bit-size as its input. Likewise, a contracting conversion must store its relatively small results into a subset of the lanes of the output vector, defaulting the unused lanes to zero.

    As an example, a conversion from `byte` to `long` (`M=8`) will discard 87.5% of the input values in order to convert the remaining 12.5% into the roomy `long` lanes of the output vector. The inverse conversion will convert back all of the large results, but will waste 87.5% of the lanes in the output vector. In-place conversions (`M=1`) deliver all of their results in one output vector, without wasting lanes.

    To manage the details of these expansions and contractions, a non-zero `part` parameter selects partial results from expansions, or steers the results of contractions into corresponding locations, as follows:

    - expanding by `M`: `part` must be in the range `[0..M-1]`, and selects the block of `VLENGTH/M` input lanes starting at the origin lane at `part*VLENGTH/M`.

      The `VLENGTH/M` output lanes represent a partial slice of the whole logical result of the conversion, filling the entire physical output vector.

    - contracting by `M`: `part` must be in the range `[-M+1..0]`, and steers all `VLENGTH` input lanes into the output located at the origin lane `-part*VLENGTH`. There is a total of `VLENGTH*M` output lanes, and those not holding converted input values are filled with zeroes.

      A group of such output vectors, with logical result parts steered to disjoint blocks, can be reassembled using the bitwise or or (for floating point) the `FIRST_NONZERO` operator.

    - in-place (`M=1`): `part` must be zero. Both vectors have the same `VLENGTH`. The result is always positioned at the origin lane of zero.

    This method is a restricted version of the more general but less frequently used shape-changing method `convertShape()`. The result of this method is the same as the expression `this.convertShape(conv, rsp, this.broadcast(part))`, where the output species is `rsp=this.species().withLanes(FTYPE.class)`.

    Specified by:
      `convert` in class `Vector<E>`
    Type Parameters:
      `F` - the boxed element type of the species
    Parameters:
      `conv` - the desired scalar conversion to apply lane-wise
      `part` - the part number of the result, or zero if neither expanding nor contracting
    Returns:
      a vector converted by shape and element type from this vector
    See Also:
      - `VectorOperators.I2L`
      - `VectorOperators.Conversion.ofCast(Class,Class)`
      - `VectorSpecies.partLimit(VectorSpecies,boolean)`
      - `Vector.viewAsFloatingLanes()`
      - `Vector.viewAsIntegralLanes()`
      - `Vector.convertShape(VectorOperators.Conversion,VectorSpecies,int)`
      - `Vector.reinterpretShape(VectorSpecies,int)`

  - ### castShape

    public final <F> Vector<F> castShape(VectorSpecies<F> toSpecies, int part)
    Convenience method for converting a vector from one lane type to another, reshaping as needed when lane sizes change. This method returns the value of this expression: `convertShape(conv,rsp,part)`, where `conv` is `VectorOperators.Conversion.ofCast(E.class,F.class)`.

    If the old and new species have different shape, this is a shape-changing operation, and may have special implementation costs.

    Specified by:
      `castShape` in class `Vector<E>`
    Type Parameters:
      `F` - the boxed element type of the output species
    Parameters:
      `toSpecies` - the desired output species
      `part` - the part number of the result, or zero if neither expanding nor contracting
    Returns:
      a vector converted by element type from this vector
    See Also:
      - `VectorOperators.Conversion.ofCast(Class,Class)`
      - `Vector.convertShape(VectorOperators.Conversion,VectorSpecies,int)`

  - ### convertShape

    public abstract <F> Vector<F> convertShape(VectorOperators.Conversion<Integer,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. This is a lane-wise operation which copies `ETYPE` values from the input vector to corresponding `FTYPE` values in the result.

    If the old and new species have the same shape, the behavior is exactly the same as the simpler, shape-invariant method `convert()`. In such cases, the simpler method `convert()` should be used, to make code easier to reason about. Otherwise, this is a shape-changing operation, and may have special implementation costs.

    As a combined effect of shape changes and lane size changes, the input and output species may have different lane counts, causing expansion or contraction. In this case a non-zero `part` parameter selects partial results from an expanded logical result, or steers the results of a contracted logical result into a physical output vector of the required output species.

    The following pseudocode illustrates the behavior of this method for in-place, expanding, and contracting conversions. (This pseudocode also applies to the shape-invariant method, but with shape restrictions on the output species.) Note that only one of the three code paths is relevant to any particular combination of conversion operator and shapes.

         FTYPE scalar_conversion_op(ETYPE s);
         EVector a = ...;
         VectorSpecies<F> rsp = ...;
         int part = ...;
         VectorSpecies<E> dsp = a.species();
         int domlen = dsp.length();
         int ranlen = rsp.length();
         FTYPE[] logical = new FTYPE[domlen];
         for (int i = 0; i < domlen; i++) {
           logical[i] = scalar_conversion_op(a.lane(i));
         }
         FTYPE[] physical;
         if (domlen == ranlen) { // in-place
             assert part == 0; //else AIOOBE
             physical = logical;
         } else if (domlen > ranlen) { // expanding
             int M = domlen / ranlen;
             assert 0 <= part && part < M; //else AIOOBE
             int origin = part * ranlen;
             physical = Arrays.copyOfRange(logical, origin, origin + ranlen);
         } else { // (domlen < ranlen) // contracting
             int M = ranlen / domlen;
             assert 0 >= part && part > -M; //else AIOOBE
             int origin = -part * domlen;
             System.arraycopy(logical, 0, physical, origin, domlen);
         }
         return FVector.fromArray(ran, physical, 0);

    Specified by:
      `convertShape` in class `Vector<E>`
    Type Parameters:
      `F` - the boxed element type of the output species
    Parameters:
      `conv` - the desired scalar conversion to apply lane-wise
      `rsp` - the desired output species
      `part` - the part number of the result, or zero if neither expanding nor contracting
    Returns:
      a vector converted by element type from this vector
    See Also:
      - `Vector.convert(VectorOperators.Conversion,int)`
      - `Vector.castShape(VectorSpecies,int)`
      - `Vector.reinterpretShape(VectorSpecies,int)`

  - ### getPayload

    protected final Object getPayload()