Uses of Class
jdk.incubator.vector.VectorShuffle

Packages that use VectorShuffle

Package	Description
jdk.incubator.vector

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 final <E> VectorShuffle<E>	VectorShuffle.fromMemorySegment(VectorSpecies<E> species, MemorySegment ms, long offset, ByteOrder bo)	Loads a shuffle from a memory segment starting at an offset into the memory segment.
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.