# Uses of Class
jdk.incubator.vector.VectorShuffle

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

## Uses of VectorShuffle in jdk.incubator.vector

Methods in jdk.incubator.vector that return VectorShuffle
Modifier and Type
Method
Description
`abstract <F> VectorShuffle<F>`
VectorShuffle.`cast(VectorSpecies<F> species)`
Converts this shuffle to a shuffle of the given species of element type `F`.
`abstract <F> VectorShuffle<F>`
VectorShuffle.`check(VectorSpecies<F> species)`
Checks that this shuffle has the given species, and returns this shuffle unchanged.
`abstract VectorShuffle<E>`
VectorShuffle.`checkIndexes()`
Apply the `checkIndex()` validation function to all lanes, throwing `IndexOutOfBoundsException` if there are any exceptional indexes in this shuffle.
`static <E> VectorShuffle<E>`
VectorShuffle.`fromArray(VectorSpecies<E> species, int[] sourceIndexes, int offset)`
Creates a shuffle for a given species from an `int` array starting at an offset.
`static <E> VectorShuffle<E>`
VectorShuffle.`fromOp(VectorSpecies<E> species, IntUnaryOperator fn)`
Creates a shuffle for a given species from the successive values of an operator applied to the range `[0..VLENGTH-1]`.
`static <E> VectorShuffle<E>`
VectorShuffle.`fromValues(VectorSpecies<E> species, int... sourceIndexes)`
Creates a shuffle for a given species from a series of source indexes.
`static <E> VectorShuffle<E>`
VectorShuffle.`iota(VectorSpecies<E> species, int start, int step, boolean wrap)`
Creates a shuffle using source indexes set to sequential values starting from `start` and stepping by the given `step`.
`VectorShuffle<E>`
VectorSpecies.`iotaShuffle(int start, int step, boolean wrap)`
Creates a shuffle using source indexes set to sequential values starting from `start` and stepping by the given `step`.
`static <E> VectorShuffle<E>`
VectorShuffle.`makeUnzip(VectorSpecies<E> species, int part)`
Creates a shuffle which will unzip the concatenation of two vectors, alternatively storing input lanes into one or the other output vector.
`static <E> VectorShuffle<E>`
VectorShuffle.`makeZip(VectorSpecies<E> species, int part)`
Creates a shuffle which will zip together two vectors, alternatively selecting lanes from one or the other.
`abstract VectorShuffle<E>`
VectorShuffle.`rearrange(VectorShuffle<E> s)`
Rearranges the lane elements of this shuffle selecting lane indexes controlled by another shuffle.
`VectorShuffle<E>`
VectorSpecies.`shuffleFromArray(int[] sourceIndexes, int offset)`
Creates a shuffle for this species from an `int` array starting at an offset.
`VectorShuffle<E>`
VectorSpecies.`shuffleFromOp(IntUnaryOperator fn)`
Creates a shuffle for this species from the successive values of an operator applied to the range `[0..VLENGTH-1]`.
`VectorShuffle<E>`
VectorSpecies.`shuffleFromValues(int... sourceIndexes)`
Creates a shuffle for this species from a series of source indexes.
`abstract VectorShuffle<E>`
Vector.`toShuffle()`
Converts this vector into a shuffle, converting the lane values to `int` and regarding them as source indexes.
`abstract VectorShuffle<E>`
VectorShuffle.`wrapIndexes()`
Apply the `wrapIndex()` validation function to all lanes, replacing any exceptional indexes with wrapped normal indexes.
Methods in jdk.incubator.vector with parameters of type VectorShuffle
Modifier and Type
Method
Description
`abstract ByteVector`
ByteVector.`rearrange(VectorShuffle<Byte> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`abstract ByteVector`
ByteVector.`rearrange(VectorShuffle<Byte> s, Vector<Byte> v)`
Rearranges the lane elements of two vectors, selecting lanes under the control of a specific shuffle, using both normal and exceptional indexes in the shuffle to steer data.
`abstract ByteVector`
ByteVector.`rearrange(VectorShuffle<Byte> s, VectorMask<Byte> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract DoubleVector`
DoubleVector.`rearrange(VectorShuffle<Double> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`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 DoubleVector`
DoubleVector.`rearrange(VectorShuffle<Double> s, VectorMask<Double> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract FloatVector`
FloatVector.`rearrange(VectorShuffle<Float> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`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 FloatVector`
FloatVector.`rearrange(VectorShuffle<Float> s, VectorMask<Float> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract IntVector`
IntVector.`rearrange(VectorShuffle<Integer> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`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 IntVector`
IntVector.`rearrange(VectorShuffle<Integer> s, VectorMask<Integer> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract LongVector`
LongVector.`rearrange(VectorShuffle<Long> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`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 LongVector`
LongVector.`rearrange(VectorShuffle<Long> s, VectorMask<Long> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`abstract ShortVector`
ShortVector.`rearrange(VectorShuffle<Short> shuffle)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle.
`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 ShortVector`
ShortVector.`rearrange(VectorShuffle<Short> s, VectorMask<Short> m)`
Rearranges the lane elements of this vector, selecting lanes under the control of a specific shuffle and a mask.
`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 VectorShuffle<E>`
VectorShuffle.`rearrange(VectorShuffle<E> s)`
Rearranges the lane elements of this shuffle selecting lane indexes controlled by another shuffle.