# Uses of Class
jdk.incubator.vector.Vector

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

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

  Subclasses of Vector in jdk.incubator.vector
  Modifier and Type
  Class
  Description
  `class`
  `ByteVector`
  A specialized `Vector` representing an ordered immutable sequence of `byte` values.
  `class`
  `DoubleVector`
  A specialized `Vector` representing an ordered immutable sequence of `double` values.
  `class`
  `FloatVector`
  A specialized `Vector` representing an ordered immutable sequence of `float` values.
  `class`
  `IntVector`
  A specialized `Vector` representing an ordered immutable sequence of `int` values.
  `class`
  `LongVector`
  A specialized `Vector` representing an ordered immutable sequence of `long` values.
  `class`
  `ShortVector`
  A specialized `Vector` representing an ordered immutable sequence of `short` values.
  Methods in jdk.incubator.vector that return Vector
  Modifier and Type
  Method
  Description
  `abstract Vector<E>`
  Vector.`abs()`
  Returns the absolute value of this vector.
  `abstract Vector<E>`
  Vector.`add(Vector<E> v)`
  Adds this vector to a second input vector.
  `abstract Vector<E>`
  Vector.`add(Vector<E> v, VectorMask<E> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract Vector<E>`
  Vector.`addIndex(int scale)`
  Adds the lanes of this vector to their corresponding lane numbers, scaled by a given constant.
  `abstract Vector<E>`
  Vector.`blend(long e, VectorMask<E> m)`
  Replaces selected lanes of this vector with a scalar value under the control of a mask.
  `abstract Vector<E>`
  Vector.`blend(Vector<E> v, VectorMask<E> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`broadcast(long e)`
  Returns a vector of the same species as this one where all lane elements are set to the primitive value `e`.
  `Vector<E>`
  VectorSpecies.`broadcast(long e)`
  Returns a vector of the given species where all lane elements are set to the primitive value `e`.
  `abstract <F> Vector<F>`
  Vector.`castShape(VectorSpecies<F> rsp, int part)`
  Convenience method for converting a vector from one lane type to another, reshaping as needed when lane sizes change.
  `abstract <F> Vector<F>`
  Vector.`check(Class<F> elementType)`
  Checks that this vector has the given element type, and returns this vector unchanged.
  `abstract <F> Vector<F>`
  Vector.`check(VectorSpecies<F> species)`
  Checks that this vector has the given species, and returns this vector unchanged.
  `abstract Vector<E>`
  Vector.`compress(VectorMask<E> m)`
  Compresses the lane elements of this vector selecting lanes under the control of a specific mask.
  `abstract <F> Vector<F>`
  Vector.`convert(VectorOperators.Conversion<E,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>`
  Vector.`convertShape(VectorOperators.Conversion<E,F> conv, VectorSpecies<F> rsp, int part)`
  Converts this vector to a vector of the given species, shape and element type, converting lane values from the current `ETYPE` to a new lane type (called `FTYPE` here) according to the indicated conversion.
  `abstract Vector<E>`
  Vector.`div(Vector<E> v)`
  Divides this vector by a second input vector.
  `abstract Vector<E>`
  Vector.`div(Vector<E> v, VectorMask<E> m)`
  Divides this vector by a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`expand(VectorMask<E> m)`
  Expands the lane elements of this vector under the control of a specific mask.
  `Vector<E>`
  VectorSpecies.`fromArray(Object a, int offset)`
  Returns a vector of this species where lane elements are initialized from the given array at the given offset.
  `Vector<E>`
  VectorSpecies.`fromMemorySegment(MemorySegmentPREVIEW ms, long offset, ByteOrder bo)`
  Loads a vector of this species from a memory segmentPREVIEW starting at an offset into the memory segment.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, long e)`
  Combines the lane values of this vector with the value of a broadcast scalar.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, long e, VectorMask<E> 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 Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, Vector<E> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> 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 Vector<E>`
  Vector.`lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> 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 Vector<E>`
  Vector.`lanewise(VectorOperators.Unary op)`
  Operates on the lane values of this vector.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Unary op, VectorMask<E> m)`
  Operates on the lane values of this vector, with selection of lane elements controlled by a mask.
  `abstract Vector<E>`
  Vector.`max(Vector<E> v)`
  Computes the larger of this vector and a second input vector.
  `abstract Vector<E>`
  Vector.`min(Vector<E> v)`
  Computes the smaller of this vector and a second input vector.
  `abstract Vector<E>`
  Vector.`mul(Vector<E> v)`
  Multiplies this vector by a second input vector.
  `abstract Vector<E>`
  Vector.`mul(Vector<E> v, VectorMask<E> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`neg()`
  Negates this vector.
  `abstract Vector<E>`
  Vector.`rearrange(VectorShuffle<E> s)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
  `abstract Vector<E>`
  Vector.`rearrange(VectorShuffle<E> s, Vector<E> 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 Vector<E>`
  Vector.`rearrange(VectorShuffle<E> s, VectorMask<E> m)`
  Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
  `abstract <F> Vector<F>`
  Vector.`reinterpretShape(VectorSpecies<F> species, int part)`
  Transforms this vector to a vector of the given species of element type `F`, reinterpreting the bytes of this vector without performing any value conversions.
  `abstract Vector<E>`
  Vector.`selectFrom(Vector<E> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract Vector<E>`
  Vector.`selectFrom(Vector<E> v, VectorMask<E> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract Vector<E>`
  Vector.`slice(int origin)`
  Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector.
  `abstract Vector<E>`
  Vector.`slice(int origin, Vector<E> 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.
  `abstract Vector<E>`
  Vector.`slice(int origin, Vector<E> v1, VectorMask<E> 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.
  `abstract Vector<E>`
  Vector.`sub(Vector<E> v)`
  Subtracts a second input vector from this vector.
  `abstract Vector<E>`
  Vector.`sub(Vector<E> v, VectorMask<E> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `abstract Vector<E>`
  VectorMask.`toVector()`
  Returns a vector representation of this mask, the lane bits of which are set or unset in correspondence to the mask bits.
  `abstract Vector<E>`
  VectorShuffle.`toVector()`
  Converts this shuffle into a vector, creating a vector of integral values corresponding to the lane source indexes of the shuffle.
  `abstract Vector<E>`
  Vector.`unslice(int origin)`
  Reverses a slice(), inserting the current vector as a slice within a "background" input of zero lane values.
  `abstract Vector<E>`
  Vector.`unslice(int origin, Vector<E> 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 Vector<E>`
  Vector.`unslice(int origin, Vector<E> w, int part, VectorMask<E> 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 Vector<?>`
  ByteVector.`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 Vector<?>`
  ShortVector.`viewAsFloatingLanes()`
  Views this vector as a vector of the same shape, length, and contents, but a lane type that is a floating-point type.
  `abstract Vector<?>`
  Vector.`viewAsFloatingLanes()`
  Views this vector as a vector of the same shape, length, and contents, but a lane type that is a floating-point type.
  `abstract Vector<?>`
  Vector.`viewAsIntegralLanes()`
  Views this vector as a vector of the same shape, length, and contents, but a lane type that is not a floating-point type.
  `Vector<E>`
  VectorSpecies.`zero()`
  Returns a vector of this species where all lane elements are set to the default primitive value, `(ETYPE)0`.
  Methods in jdk.incubator.vector that return types with arguments of type Vector
  Modifier and Type
  Method
  Description
  `Class<? extends Vector<E>>`
  VectorSpecies.`vectorType()`
  Returns the vector type of this species.
  Methods in jdk.incubator.vector with parameters of type Vector
  Modifier and Type
  Method
  Description
  `final ByteVector`
  ByteVector.`add(Vector<Byte> v)`
  Adds this vector to a second input vector.
  `final ByteVector`
  ByteVector.`add(Vector<Byte> v, VectorMask<Byte> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final DoubleVector`
  DoubleVector.`add(Vector<Double> v)`
  Adds this vector to a second input vector.
  `final DoubleVector`
  DoubleVector.`add(Vector<Double> v, VectorMask<Double> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final FloatVector`
  FloatVector.`add(Vector<Float> v)`
  Adds this vector to a second input vector.
  `final FloatVector`
  FloatVector.`add(Vector<Float> v, VectorMask<Float> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final IntVector`
  IntVector.`add(Vector<Integer> v)`
  Adds this vector to a second input vector.
  `final IntVector`
  IntVector.`add(Vector<Integer> v, VectorMask<Integer> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final LongVector`
  LongVector.`add(Vector<Long> v)`
  Adds this vector to a second input vector.
  `final LongVector`
  LongVector.`add(Vector<Long> v, VectorMask<Long> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final ShortVector`
  ShortVector.`add(Vector<Short> v)`
  Adds this vector to a second input vector.
  `final ShortVector`
  ShortVector.`add(Vector<Short> v, VectorMask<Short> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `abstract Vector<E>`
  Vector.`add(Vector<E> v)`
  Adds this vector to a second input vector.
  `abstract Vector<E>`
  Vector.`add(Vector<E> v, VectorMask<E> m)`
  Adds this vector to a second input vector, selecting lanes under the control of a mask.
  `final ByteVector`
  ByteVector.`and(Vector<Byte> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final IntVector`
  IntVector.`and(Vector<Integer> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final LongVector`
  LongVector.`and(Vector<Long> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final ShortVector`
  ShortVector.`and(Vector<Short> v)`
  Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`bitwiseBlend(byte bits, Vector<Byte> mask)`
  Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
  `final ByteVector`
  ByteVector.`bitwiseBlend(Vector<Byte> bits, byte mask)`
  Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
  `final ByteVector`
  ByteVector.`bitwiseBlend(Vector<Byte> bits, Vector<Byte> mask)`
  Blends together the bits of two vectors under the control of a third, which supplies mask bits.
  `final IntVector`
  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`
  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`
  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 LongVector`
  LongVector.`bitwiseBlend(long bits, Vector<Long> mask)`
  Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
  `final LongVector`
  LongVector.`bitwiseBlend(Vector<Long> bits, long mask)`
  Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
  `final LongVector`
  LongVector.`bitwiseBlend(Vector<Long> bits, Vector<Long> mask)`
  Blends together the bits of two vectors under the control of a third, which supplies mask bits.
  `final ShortVector`
  ShortVector.`bitwiseBlend(short bits, Vector<Short> mask)`
  Blends together the bits of a vector and a scalar under the control of another vector, which supplies mask bits.
  `final ShortVector`
  ShortVector.`bitwiseBlend(Vector<Short> bits, short mask)`
  Blends together the bits of two vectors under the control of a scalar, which supplies mask bits.
  `final ShortVector`
  ShortVector.`bitwiseBlend(Vector<Short> bits, Vector<Short> mask)`
  Blends together the bits of two vectors under the control of a third, which supplies mask bits.
  `abstract ByteVector`
  ByteVector.`blend(Vector<Byte> v, VectorMask<Byte> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract DoubleVector`
  DoubleVector.`blend(Vector<Double> v, VectorMask<Double> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract FloatVector`
  FloatVector.`blend(Vector<Float> v, VectorMask<Float> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract IntVector`
  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 LongVector`
  LongVector.`blend(Vector<Long> v, VectorMask<Long> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract ShortVector`
  ShortVector.`blend(Vector<Short> v, VectorMask<Short> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`blend(Vector<E> v, VectorMask<E> m)`
  Replaces selected lanes of this vector with corresponding lanes from a second input vector under the control of a mask.
  `abstract VectorMask<Byte>`
  ByteVector.`compare(VectorOperators.Comparison op, Vector<Byte> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<Double>`
  DoubleVector.`compare(VectorOperators.Comparison op, Vector<Double> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<Float>`
  FloatVector.`compare(VectorOperators.Comparison op, Vector<Float> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<Integer>`
  IntVector.`compare(VectorOperators.Comparison op, Vector<Integer> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<Long>`
  LongVector.`compare(VectorOperators.Comparison op, Vector<Long> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<Short>`
  ShortVector.`compare(VectorOperators.Comparison op, Vector<Short> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<E>`
  Vector.`compare(VectorOperators.Comparison op, Vector<E> v)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation.
  `abstract VectorMask<E>`
  Vector.`compare(VectorOperators.Comparison op, Vector<E> v, VectorMask<E> m)`
  Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `final ByteVector`
  ByteVector.`div(Vector<Byte> v)`
  Divides this vector by a second input vector.
  `final ByteVector`
  ByteVector.`div(Vector<Byte> v, VectorMask<Byte> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final DoubleVector`
  DoubleVector.`div(Vector<Double> v)`
  Divides this vector by a second input vector.
  `final DoubleVector`
  DoubleVector.`div(Vector<Double> v, VectorMask<Double> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final FloatVector`
  FloatVector.`div(Vector<Float> v)`
  Divides this vector by a second input vector.
  `final FloatVector`
  FloatVector.`div(Vector<Float> v, VectorMask<Float> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final IntVector`
  IntVector.`div(Vector<Integer> v)`
  Divides this vector by a second input vector.
  `final IntVector`
  IntVector.`div(Vector<Integer> v, VectorMask<Integer> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final LongVector`
  LongVector.`div(Vector<Long> v)`
  Divides this vector by a second input vector.
  `final LongVector`
  LongVector.`div(Vector<Long> v, VectorMask<Long> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final ShortVector`
  ShortVector.`div(Vector<Short> v)`
  Divides this vector by a second input vector.
  `final ShortVector`
  ShortVector.`div(Vector<Short> v, VectorMask<Short> m)`
  Divides this vector by a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`div(Vector<E> v)`
  Divides this vector by a second input vector.
  `abstract Vector<E>`
  Vector.`div(Vector<E> v, VectorMask<E> m)`
  Divides this vector by a second input vector under the control of a mask.
  `final VectorMask<Byte>`
  ByteVector.`eq(Vector<Byte> v)`
  Tests if this vector is equal to another input vector.
  `final VectorMask<Double>`
  DoubleVector.`eq(Vector<Double> v)`
  Tests if this vector is equal to another input vector.
  `final VectorMask<Float>`
  FloatVector.`eq(Vector<Float> v)`
  Tests if this vector is equal to another input vector.
  `final VectorMask<Integer>`
  IntVector.`eq(Vector<Integer> v)`
  Tests if this vector is equal to another input vector.
  `final VectorMask<Long>`
  LongVector.`eq(Vector<Long> v)`
  Tests if this vector is equal to another input vector.
  `final VectorMask<Short>`
  ShortVector.`eq(Vector<Short> v)`
  Tests if this vector is equal to another input vector.
  `abstract VectorMask<E>`
  Vector.`eq(Vector<E> v)`
  Tests if this vector is equal to another input vector.
  `final DoubleVector`
  DoubleVector.`fma(Vector<Double> b, Vector<Double> c)`
  Multiplies this vector by a second input vector, and sums the result with a third.
  `final FloatVector`
  FloatVector.`fma(Vector<Float> b, Vector<Float> c)`
  Multiplies this vector by a second input vector, and sums the result with a third.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, Vector<Byte> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Binary op, Vector<Byte> v, VectorMask<Byte> m)`
  Combines the corresponding lane values of this vector with those of a second input vector, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, byte e1, Vector<Byte> v2, VectorMask<Byte> m)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, byte e2, VectorMask<Byte> m)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar, with selection of lane elements controlled by a mask.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract ByteVector`
  ByteVector.`lanewise(VectorOperators.Ternary op, Vector<Byte> v1, Vector<Byte> v2, VectorMask<Byte> m)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector, with selection of lane elements controlled by a mask.
  `abstract DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Binary op, Vector<Double> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Binary op, Vector<Double> v, VectorMask<Double> 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 DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, double e1, Vector<Double> v2, VectorMask<Double> 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 DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, Vector<Double> v1, double e2, VectorMask<Double> 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 DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract DoubleVector`
  DoubleVector.`lanewise(VectorOperators.Ternary op, Vector<Double> v1, Vector<Double> v2, VectorMask<Double> 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 FloatVector`
  FloatVector.`lanewise(VectorOperators.Binary op, Vector<Float> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract FloatVector`
  FloatVector.`lanewise(VectorOperators.Binary op, Vector<Float> v, VectorMask<Float> 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 FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, float e1, Vector<Float> v2, VectorMask<Float> 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 FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, Vector<Float> v1, float e2, VectorMask<Float> 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 FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract FloatVector`
  FloatVector.`lanewise(VectorOperators.Ternary op, Vector<Float> v1, Vector<Float> v2, VectorMask<Float> 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`
  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`
  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`
  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`
  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`
  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`
  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`
  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`
  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 LongVector`
  LongVector.`lanewise(VectorOperators.Binary op, Vector<Long> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract LongVector`
  LongVector.`lanewise(VectorOperators.Binary op, Vector<Long> v, VectorMask<Long> 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 LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, long e1, Vector<Long> v2, VectorMask<Long> 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 LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, Vector<Long> v1, long e2, VectorMask<Long> 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 LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract LongVector`
  LongVector.`lanewise(VectorOperators.Ternary op, Vector<Long> v1, Vector<Long> v2, VectorMask<Long> 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 ShortVector`
  ShortVector.`lanewise(VectorOperators.Binary op, Vector<Short> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract ShortVector`
  ShortVector.`lanewise(VectorOperators.Binary op, Vector<Short> v, VectorMask<Short> 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 ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, short e1, Vector<Short> v2, VectorMask<Short> 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 ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2)`
  Combines the lane values of this vector with the values of another vector and a broadcast scalar.
  `final ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, Vector<Short> v1, short e2, VectorMask<Short> 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 ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract ShortVector`
  ShortVector.`lanewise(VectorOperators.Ternary op, Vector<Short> v1, Vector<Short> v2, VectorMask<Short> 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 Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, Vector<E> v)`
  Combines the corresponding lane values of this vector with those of a second input vector.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Binary op, Vector<E> v, VectorMask<E> 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 Vector<E>`
  Vector.`lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2)`
  Combines the corresponding lane values of this vector with the lanes of a second and a third input vector.
  `abstract Vector<E>`
  Vector.`lanewise(VectorOperators.Ternary op, Vector<E> v1, Vector<E> v2, VectorMask<E> 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.
  `final VectorMask<Byte>`
  ByteVector.`lt(Vector<Byte> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Double>`
  DoubleVector.`lt(Vector<Double> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Float>`
  FloatVector.`lt(Vector<Float> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Integer>`
  IntVector.`lt(Vector<Integer> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Long>`
  LongVector.`lt(Vector<Long> v)`
  Tests if this vector is less than another input vector.
  `final VectorMask<Short>`
  ShortVector.`lt(Vector<Short> v)`
  Tests if this vector is less than another input vector.
  `abstract VectorMask<E>`
  Vector.`lt(Vector<E> v)`
  Tests if this vector is less than another input vector.
  `final ByteVector`
  ByteVector.`max(Vector<Byte> v)`
  Computes the larger of this vector and a second input vector.
  `final DoubleVector`
  DoubleVector.`max(Vector<Double> v)`
  Computes the larger of this vector and a second input vector.
  `final FloatVector`
  FloatVector.`max(Vector<Float> v)`
  Computes the larger of this vector and a second input vector.
  `final IntVector`
  IntVector.`max(Vector<Integer> v)`
  Computes the larger of this vector and a second input vector.
  `final LongVector`
  LongVector.`max(Vector<Long> v)`
  Computes the larger of this vector and a second input vector.
  `final ShortVector`
  ShortVector.`max(Vector<Short> v)`
  Computes the larger of this vector and a second input vector.
  `abstract Vector<E>`
  Vector.`max(Vector<E> v)`
  Computes the larger of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`min(Vector<Byte> v)`
  Computes the smaller of this vector and a second input vector.
  `final DoubleVector`
  DoubleVector.`min(Vector<Double> v)`
  Computes the smaller of this vector and a second input vector.
  `final FloatVector`
  FloatVector.`min(Vector<Float> v)`
  Computes the smaller of this vector and a second input vector.
  `final IntVector`
  IntVector.`min(Vector<Integer> v)`
  Computes the smaller of this vector and a second input vector.
  `final LongVector`
  LongVector.`min(Vector<Long> v)`
  Computes the smaller of this vector and a second input vector.
  `final ShortVector`
  ShortVector.`min(Vector<Short> v)`
  Computes the smaller of this vector and a second input vector.
  `abstract Vector<E>`
  Vector.`min(Vector<E> v)`
  Computes the smaller of this vector and a second input vector.
  `final ByteVector`
  ByteVector.`mul(Vector<Byte> v)`
  Multiplies this vector by a second input vector.
  `final ByteVector`
  ByteVector.`mul(Vector<Byte> v, VectorMask<Byte> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final DoubleVector`
  DoubleVector.`mul(Vector<Double> v)`
  Multiplies this vector by a second input vector.
  `final DoubleVector`
  DoubleVector.`mul(Vector<Double> v, VectorMask<Double> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final FloatVector`
  FloatVector.`mul(Vector<Float> v)`
  Multiplies this vector by a second input vector.
  `final FloatVector`
  FloatVector.`mul(Vector<Float> v, VectorMask<Float> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final IntVector`
  IntVector.`mul(Vector<Integer> v)`
  Multiplies this vector by a second input vector.
  `final IntVector`
  IntVector.`mul(Vector<Integer> v, VectorMask<Integer> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final LongVector`
  LongVector.`mul(Vector<Long> v)`
  Multiplies this vector by a second input vector.
  `final LongVector`
  LongVector.`mul(Vector<Long> v, VectorMask<Long> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final ShortVector`
  ShortVector.`mul(Vector<Short> v)`
  Multiplies this vector by a second input vector.
  `final ShortVector`
  ShortVector.`mul(Vector<Short> v, VectorMask<Short> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`mul(Vector<E> v)`
  Multiplies this vector by a second input vector.
  `abstract Vector<E>`
  Vector.`mul(Vector<E> v, VectorMask<E> m)`
  Multiplies this vector by a second input vector under the control of a mask.
  `final ByteVector`
  ByteVector.`or(Vector<Byte> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `final IntVector`
  IntVector.`or(Vector<Integer> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `final LongVector`
  LongVector.`or(Vector<Long> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `final ShortVector`
  ShortVector.`or(Vector<Short> v)`
  Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `final DoubleVector`
  DoubleVector.`pow(Vector<Double> b)`
  Raises this vector to the power of a second input vector.
  `final FloatVector`
  FloatVector.`pow(Vector<Float> b)`
  Raises this vector to the power of a second input vector.
  `abstract ByteVector`
  ByteVector.`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`
  Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
  `abstract DoubleVector`
  DoubleVector.`rearrange(VectorShuffle<Double> s, Vector<Double> 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 FloatVector`
  FloatVector.`rearrange(VectorShuffle<Float> s, Vector<Float> 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`
  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 LongVector`
  LongVector.`rearrange(VectorShuffle<Long> s, Vector<Long> 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 ShortVector`
  ShortVector.`rearrange(VectorShuffle<Short> s, Vector<Short> 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 Vector<E>`
  Vector.`rearrange(VectorShuffle<E> s, Vector<E> v)`
  Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
  `abstract ByteVector`
  ByteVector.`selectFrom(Vector<Byte> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract ByteVector`
  ByteVector.`selectFrom(Vector<Byte> s, VectorMask<Byte> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract DoubleVector`
  DoubleVector.`selectFrom(Vector<Double> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract DoubleVector`
  DoubleVector.`selectFrom(Vector<Double> s, VectorMask<Double> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract FloatVector`
  FloatVector.`selectFrom(Vector<Float> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract FloatVector`
  FloatVector.`selectFrom(Vector<Float> s, VectorMask<Float> 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`
  IntVector.`selectFrom(Vector<Integer> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract IntVector`
  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 LongVector`
  LongVector.`selectFrom(Vector<Long> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract LongVector`
  LongVector.`selectFrom(Vector<Long> s, VectorMask<Long> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract ShortVector`
  ShortVector.`selectFrom(Vector<Short> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract ShortVector`
  ShortVector.`selectFrom(Vector<Short> s, VectorMask<Short> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract Vector<E>`
  Vector.`selectFrom(Vector<E> v)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector `v`.
  `abstract Vector<E>`
  Vector.`selectFrom(Vector<E> v, VectorMask<E> m)`
  Using index values stored in the lanes of this vector, assemble values stored in second vector, under the control of a mask.
  `abstract ByteVector`
  ByteVector.`slice(int origin, Vector<Byte> v1)`
  Slices a segment of adjacent lanes, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `final ByteVector`
  ByteVector.`slice(int origin, Vector<Byte> w, VectorMask<Byte> m)`
  Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `abstract DoubleVector`
  DoubleVector.`slice(int origin, Vector<Double> 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 DoubleVector`
  DoubleVector.`slice(int origin, Vector<Double> w, VectorMask<Double> 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.
  `abstract FloatVector`
  FloatVector.`slice(int origin, Vector<Float> 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 FloatVector`
  FloatVector.`slice(int origin, Vector<Float> w, VectorMask<Float> 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.
  `abstract IntVector`
  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`
  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.
  `abstract LongVector`
  LongVector.`slice(int origin, Vector<Long> 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 LongVector`
  LongVector.`slice(int origin, Vector<Long> w, VectorMask<Long> 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.
  `abstract ShortVector`
  ShortVector.`slice(int origin, Vector<Short> 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 ShortVector`
  ShortVector.`slice(int origin, Vector<Short> w, VectorMask<Short> 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.
  `abstract Vector<E>`
  Vector.`slice(int origin, Vector<E> 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.
  `abstract Vector<E>`
  Vector.`slice(int origin, Vector<E> v1, VectorMask<E> m)`
  Slices a segment of adjacent lanes under the control of a mask, starting at a given `origin` lane in the current vector, and continuing (as needed) into an immediately following vector.
  `final ByteVector`
  ByteVector.`sub(Vector<Byte> v)`
  Subtracts a second input vector from this vector.
  `final ByteVector`
  ByteVector.`sub(Vector<Byte> v, VectorMask<Byte> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `final DoubleVector`
  DoubleVector.`sub(Vector<Double> v)`
  Subtracts a second input vector from this vector.
  `final DoubleVector`
  DoubleVector.`sub(Vector<Double> v, VectorMask<Double> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `final FloatVector`
  FloatVector.`sub(Vector<Float> v)`
  Subtracts a second input vector from this vector.
  `final FloatVector`
  FloatVector.`sub(Vector<Float> v, VectorMask<Float> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `final IntVector`
  IntVector.`sub(Vector<Integer> v)`
  Subtracts a second input vector from this vector.
  `final IntVector`
  IntVector.`sub(Vector<Integer> v, VectorMask<Integer> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `final LongVector`
  LongVector.`sub(Vector<Long> v)`
  Subtracts a second input vector from this vector.
  `final LongVector`
  LongVector.`sub(Vector<Long> v, VectorMask<Long> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `final ShortVector`
  ShortVector.`sub(Vector<Short> v)`
  Subtracts a second input vector from this vector.
  `final ShortVector`
  ShortVector.`sub(Vector<Short> v, VectorMask<Short> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `abstract Vector<E>`
  Vector.`sub(Vector<E> v)`
  Subtracts a second input vector from this vector.
  `abstract Vector<E>`
  Vector.`sub(Vector<E> v, VectorMask<E> m)`
  Subtracts a second input vector from this vector under the control of a mask.
  `abstract ByteVector`
  ByteVector.`unslice(int origin, Vector<Byte> w, int part)`
  Reverses a slice(), inserting the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract ByteVector`
  ByteVector.`unslice(int origin, Vector<Byte> w, int part, VectorMask<Byte> m)`
  Reverses a slice(), inserting (under the control of a mask) the current vector as a slice within another "background" input vector, which is regarded as one or the other input to a hypothetical subsequent `slice()` operation.
  `abstract DoubleVector`
  DoubleVector.`unslice(int origin, Vector<Double> 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 DoubleVector`
  DoubleVector.`unslice(int origin, Vector<Double> w, int part, VectorMask<Double> 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.
  `abstract FloatVector`
  FloatVector.`unslice(int origin, Vector<Float> 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 FloatVector`
  FloatVector.`unslice(int origin, Vector<Float> w, int part, VectorMask<Float> 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.
  `abstract IntVector`
  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`
  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.
  `abstract LongVector`
  LongVector.`unslice(int origin, Vector<Long> 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 LongVector`
  LongVector.`unslice(int origin, Vector<Long> w, int part, VectorMask<Long> 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.
  `abstract ShortVector`
  ShortVector.`unslice(int origin, Vector<Short> 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 ShortVector`
  ShortVector.`unslice(int origin, Vector<Short> w, int part, VectorMask<Short> 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.
  `abstract Vector<E>`
  Vector.`unslice(int origin, Vector<E> 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 Vector<E>`
  Vector.`unslice(int origin, Vector<E> w, int part, VectorMask<E> 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.