# 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 <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.
  `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.`fromByteArray​(byte[] a, int offset)` | Returns a vector of this species where lane elements are initialized from the given byte array at the given offset.
  `Vector<E>` | VectorSpecies.`fromValues​(long... values)` | Returns a vector of this species where lane elements are initialized from the given sequence of `long`s.
  `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.
  `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.
  `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
  --- | --- | ---
  `ByteVector` | ByteVector.`add​(Vector<Byte> v)` | Adds this vector to a second input vector.
  `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.
  `DoubleVector` | DoubleVector.`add​(Vector<Double> v)` | Adds this vector to a second input vector.
  `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.
  `FloatVector` | FloatVector.`add​(Vector<Float> v)` | Adds this vector to a second input vector.
  `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.
  `IntVector` | IntVector.`add​(Vector<Integer> v)` | Adds this vector to a second input vector.
  `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.
  `LongVector` | LongVector.`add​(Vector<Long> v)` | Adds this vector to a second input vector.
  `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.
  `ShortVector` | ShortVector.`add​(Vector<Short> v)` | Adds this vector to a second input vector.
  `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.
  `ByteVector` | ByteVector.`and​(Vector<Byte> v)` | Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `IntVector` | IntVector.`and​(Vector<Integer> v)` | Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `LongVector` | LongVector.`and​(Vector<Long> v)` | Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `ShortVector` | ShortVector.`and​(Vector<Short> v)` | Computes the bitwise logical conjunction (`&`) of this vector and a second input vector.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `VectorMask<Byte>` | ByteVector.`compare​(VectorOperators.Comparison op, Vector<Byte> v, VectorMask<Byte> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `VectorMask<Double>` | DoubleVector.`compare​(VectorOperators.Comparison op, Vector<Double> v, VectorMask<Double> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `VectorMask<Float>` | FloatVector.`compare​(VectorOperators.Comparison op, Vector<Float> v, VectorMask<Float> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `VectorMask<Integer>` | IntVector.`compare​(VectorOperators.Comparison op, Vector<Integer> v, VectorMask<Integer> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `VectorMask<Long>` | LongVector.`compare​(VectorOperators.Comparison op, Vector<Long> v, VectorMask<Long> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `VectorMask<Short>` | ShortVector.`compare​(VectorOperators.Comparison op, Vector<Short> v, VectorMask<Short> m)` | Tests this vector by comparing it with another input vector, according to the given comparison operation, in lanes selected by a mask.
  `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.
  `ByteVector` | ByteVector.`div​(Vector<Byte> v)` | Divides this vector by a second input vector.
  `ByteVector` | ByteVector.`div​(Vector<Byte> v, VectorMask<Byte> m)` | Divides this vector by a second input vector under the control of a mask.
  `DoubleVector` | DoubleVector.`div​(Vector<Double> v)` | Divides this vector by a second input vector.
  `DoubleVector` | DoubleVector.`div​(Vector<Double> v, VectorMask<Double> m)` | Divides this vector by a second input vector under the control of a mask.
  `FloatVector` | FloatVector.`div​(Vector<Float> v)` | Divides this vector by a second input vector.
  `FloatVector` | FloatVector.`div​(Vector<Float> v, VectorMask<Float> m)` | Divides this vector by a second input vector under the control of a mask.
  `IntVector` | IntVector.`div​(Vector<Integer> v)` | Divides this vector by a second input vector.
  `IntVector` | IntVector.`div​(Vector<Integer> v, VectorMask<Integer> m)` | Divides this vector by a second input vector under the control of a mask.
  `LongVector` | LongVector.`div​(Vector<Long> v)` | Divides this vector by a second input vector.
  `LongVector` | LongVector.`div​(Vector<Long> v, VectorMask<Long> m)` | Divides this vector by a second input vector under the control of a mask.
  `ShortVector` | ShortVector.`div​(Vector<Short> v)` | Divides this vector by a second input vector.
  `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.
  `VectorMask<Byte>` | ByteVector.`eq​(Vector<Byte> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Double>` | DoubleVector.`eq​(Vector<Double> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Float>` | FloatVector.`eq​(Vector<Float> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Integer>` | IntVector.`eq​(Vector<Integer> v)` | Tests if this vector is equal to another input vector.
  `VectorMask<Long>` | LongVector.`eq​(Vector<Long> v)` | Tests if this vector is equal to another input vector.
  `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.
  `DoubleVector` | DoubleVector.`fma​(Vector<Double> b, Vector<Double> c)` | Multiplies this vector by a second input vector, and sums the result with a third.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `VectorMask<Byte>` | ByteVector.`lt​(Vector<Byte> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Double>` | DoubleVector.`lt​(Vector<Double> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Float>` | FloatVector.`lt​(Vector<Float> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Integer>` | IntVector.`lt​(Vector<Integer> v)` | Tests if this vector is less than another input vector.
  `VectorMask<Long>` | LongVector.`lt​(Vector<Long> v)` | Tests if this vector is less than another input vector.
  `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.
  `ByteVector` | ByteVector.`max​(Vector<Byte> v)` | Computes the larger of this vector and a second input vector.
  `DoubleVector` | DoubleVector.`max​(Vector<Double> v)` | Computes the larger of this vector and a second input vector.
  `FloatVector` | FloatVector.`max​(Vector<Float> v)` | Computes the larger of this vector and a second input vector.
  `IntVector` | IntVector.`max​(Vector<Integer> v)` | Computes the larger of this vector and a second input vector.
  `LongVector` | LongVector.`max​(Vector<Long> v)` | Computes the larger of this vector and a second input vector.
  `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.
  `ByteVector` | ByteVector.`min​(Vector<Byte> v)` | Computes the smaller of this vector and a second input vector.
  `DoubleVector` | DoubleVector.`min​(Vector<Double> v)` | Computes the smaller of this vector and a second input vector.
  `FloatVector` | FloatVector.`min​(Vector<Float> v)` | Computes the smaller of this vector and a second input vector.
  `IntVector` | IntVector.`min​(Vector<Integer> v)` | Computes the smaller of this vector and a second input vector.
  `LongVector` | LongVector.`min​(Vector<Long> v)` | Computes the smaller of this vector and a second input vector.
  `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.
  `ByteVector` | ByteVector.`mul​(Vector<Byte> v)` | Multiplies this vector by a second input vector.
  `ByteVector` | ByteVector.`mul​(Vector<Byte> v, VectorMask<Byte> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `DoubleVector` | DoubleVector.`mul​(Vector<Double> v)` | Multiplies this vector by a second input vector.
  `DoubleVector` | DoubleVector.`mul​(Vector<Double> v, VectorMask<Double> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `FloatVector` | FloatVector.`mul​(Vector<Float> v)` | Multiplies this vector by a second input vector.
  `FloatVector` | FloatVector.`mul​(Vector<Float> v, VectorMask<Float> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `IntVector` | IntVector.`mul​(Vector<Integer> v)` | Multiplies this vector by a second input vector.
  `IntVector` | IntVector.`mul​(Vector<Integer> v, VectorMask<Integer> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `LongVector` | LongVector.`mul​(Vector<Long> v)` | Multiplies this vector by a second input vector.
  `LongVector` | LongVector.`mul​(Vector<Long> v, VectorMask<Long> m)` | Multiplies this vector by a second input vector under the control of a mask.
  `ShortVector` | ShortVector.`mul​(Vector<Short> v)` | Multiplies this vector by a second input vector.
  `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.
  `ByteVector` | ByteVector.`or​(Vector<Byte> v)` | Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `IntVector` | IntVector.`or​(Vector<Integer> v)` | Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `LongVector` | LongVector.`or​(Vector<Long> v)` | Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `ShortVector` | ShortVector.`or​(Vector<Short> v)` | Computes the bitwise logical disjunction (`|`) of this vector and a second input vector.
  `DoubleVector` | DoubleVector.`pow​(Vector<Double> n)` | Raises this vector to the power of a second input vector.
  `FloatVector` | FloatVector.`pow​(Vector<Float> n)` | 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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `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.
  `ByteVector` | ByteVector.`sub​(Vector<Byte> v)` | Subtracts a second input vector from this vector.
  `ByteVector` | ByteVector.`sub​(Vector<Byte> v, VectorMask<Byte> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `DoubleVector` | DoubleVector.`sub​(Vector<Double> v)` | Subtracts a second input vector from this vector.
  `DoubleVector` | DoubleVector.`sub​(Vector<Double> v, VectorMask<Double> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `FloatVector` | FloatVector.`sub​(Vector<Float> v)` | Subtracts a second input vector from this vector.
  `FloatVector` | FloatVector.`sub​(Vector<Float> v, VectorMask<Float> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `IntVector` | IntVector.`sub​(Vector<Integer> v)` | Subtracts a second input vector from this vector.
  `IntVector` | IntVector.`sub​(Vector<Integer> v, VectorMask<Integer> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `LongVector` | LongVector.`sub​(Vector<Long> v)` | Subtracts a second input vector from this vector.
  `LongVector` | LongVector.`sub​(Vector<Long> v, VectorMask<Long> m)` | Subtracts a second input vector from this vector under the control of a mask.
  `ShortVector` | ShortVector.`sub​(Vector<Short> v)` | Subtracts a second input vector from this vector.
  `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.