Computes the logical intersection (as a&b
)
between this mask and a second input mask.
Logically subtracts a second input mask
from this mask (as a&~b
).
Converts this mask to a mask of the given species of
element type F
.
Checks that this mask applies to vectors with the given element type,
and returns this mask unchanged.
Checks that this mask has the given species,
and returns this mask unchanged.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation.
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
Compresses set lanes from this mask.
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
DoubleVector.eq(double e)
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
Tests if this vector is equal to an input scalar.
Tests if this vector is equal to another input vector.
Tests if this vector is equal to another input vector.
Determines logical equivalence of this mask
to a second input mask (as boolean a==b
or a^~b
).
Loads a mask from a boolean
array starting at an offset.
Returns a mask where each lane is set or unset according to
the bits in the given bitmask, starting with the least
significant bit, and continuing up to the sign bit.
Returns a mask where each lane is set or unset according to given
boolean
values.
Removes lanes numbered N
from this mask where the
adjusted index N+offset
, is not in the range
[0..limit-1]
.
Removes lanes numbered N
from this mask where the
adjusted index N+offset
, is not in the range
[0..limit-1]
.
Returns a mask of this species where only
the lanes at index N such that the adjusted index
N+offset
is in the range [0..limit-1]
are set.
Returns a mask of this species where only
the lanes at index N such that the adjusted index
N+offset
is in the range [0..limit-1]
are set.
Find all lanes containing valid indexes (non-negative values)
and return a mask where exactly those lanes are set.
VectorSpecies.loadMask(boolean[] bits,
int offset)
Returns a mask of this species
where lane elements are initialized
from the given array at the given offset.
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
DoubleVector.lt(double e)
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
Tests if this vector is less than an input scalar.
Tests if this vector is less than another input vector.
Tests if this vector is less than another input vector.
Returns a mask of same species as this vector,
where each lane is set or unset according to given
single boolean, which is broadcast to all lanes.
Returns a mask of this species,
where each lane is set or unset according to given
single boolean, which is broadcast to all lanes.
Logically negates this mask.
Computes the logical union (as a|b
) of this mask
and a second input mask.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Tests the lanes of this vector
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Determines logical symmetric difference
(as a^b
) of this mask and a second input mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Adds this vector to a second input vector, selecting lanes
under the control of a mask.
Computes the logical intersection (as a&b
)
between this mask and a second input mask.
Logically subtracts a second input mask
from this mask (as a&~b
).
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Replaces selected lanes of this vector with
a scalar value
under the control of a mask.
Replaces selected lanes of this vector with
corresponding lanes from a second input vector
under the control of a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with an input scalar,
according to the given comparison operation,
in lanes selected by a mask.
Tests this vector by comparing it with another input vector,
according to the given comparison operation,
in lanes selected by a mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Compresses the lane elements of this vector selecting lanes
under the control of a specific mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Divides this vector by a second input vector
under the control of a mask.
Divides this vector by a second input vector
under the control of a mask.
Determines logical equivalence of this mask
to a second input mask (as boolean a==b
or a^~b
).
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Expands the lane elements of this vector
under the control of a specific mask.
Gathers a new vector composed of elements from an array of type
byte[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type byte[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
double[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type double[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
float[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type float[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
int[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type int[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
long[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type long[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
short[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type short[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
boolean[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type boolean[]
starting at an offset and using a mask.
Gathers a new vector composed of elements from an array of type
char[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
Loads a vector from an array of type char[]
starting at an offset and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
Loads a vector from a
memory segmentPREVIEW
starting at an offset into the memory segment
and using a mask.
final void
Scatters this vector into an array of type byte[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type byte[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type double[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type double[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type float[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type float[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type int[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type int[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type long[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type long[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type short[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type short[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type boolean[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type boolean[]
starting at offset and using a mask.
final void
Scatters this vector into an array of type char[]
,
under the control of a mask, and
using indexes obtained by adding a fixed offset
to a
series of secondary offsets from an index map.
final void
Stores this vector into an array of type char[]
starting at offset and using a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
final void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
abstract void
Stores this vector into a
memory segmentPREVIEW
starting at an offset using explicit byte order and a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the value of a broadcast scalar,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the lane values of this vector
with the values of two broadcast scalars,
with selection of lane elements controlled by a mask.
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.
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.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
Combines the corresponding lane values of this vector
with those of a second input vector,
with selection of lane elements controlled by a mask.
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.
Operates on the lane values of this vector,
with selection of lane elements controlled by a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by the broadcast of an input scalar,
selecting lane elements controlled by a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Multiplies this vector by a second input vector
under the control of a mask.
Computes the logical union (as a|b
) of this mask
and a second input mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
Rearranges the lane elements of this vector, selecting lanes
under the control of a specific shuffle and a mask.
abstract byte
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract double
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract float
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract int
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract long
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract short
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
abstract long
Returns a value accumulated from selected lanes of this vector,
controlled by a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
Using index values stored in the lanes of this vector,
assemble values stored in second vector, under the control
of a mask.
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.
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.
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.
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.
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.
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.
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.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts an input scalar from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Subtracts a second input vector from this vector
under the control of a mask.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
Test selected lanes of this vector,
according to the given operation.
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.
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.
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.
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.
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.
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.
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.
Determines logical symmetric difference
(as a^b
) of this mask and a second input mask.