Struct packed_simd_2::Simd [−][src]
#[repr(transparent)]pub struct Simd<A: SimdArray>(_);
Expand description
Packed SIMD vector type.
Examples
let v = Simd::<[i32; 4]>::new(0, 1, 2, 3);
assert_eq!(v.extract(2), 2);
Implementations
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
pub const fn new(
x0: i8,
x1: i8,
x2: i8,
x3: i8,
x4: i8,
x5: i8,
x6: i8,
x7: i8,
x8: i8,
x9: i8,
x10: i8,
x11: i8,
x12: i8,
x13: i8,
x14: i8,
x15: i8,
x16: i8,
x17: i8,
x18: i8,
x19: i8,
x20: i8,
x21: i8,
x22: i8,
x23: i8,
x24: i8,
x25: i8,
x26: i8,
x27: i8,
x28: i8,
x29: i8,
x30: i8,
x31: i8
) -> Self
pub const fn new(
x0: i8,
x1: i8,
x2: i8,
x3: i8,
x4: i8,
x5: i8,
x6: i8,
x7: i8,
x8: i8,
x9: i8,
x10: i8,
x11: i8,
x12: i8,
x13: i8,
x14: i8,
x15: i8,
x16: i8,
x17: i8,
x18: i8,
x19: i8,
x20: i8,
x21: i8,
x22: i8,
x23: i8,
x24: i8,
x25: i8,
x26: i8,
x27: i8,
x28: i8,
x29: i8,
x30: i8,
x31: i8
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: u8,
x1: u8,
x2: u8,
x3: u8,
x4: u8,
x5: u8,
x6: u8,
x7: u8,
x8: u8,
x9: u8,
x10: u8,
x11: u8,
x12: u8,
x13: u8,
x14: u8,
x15: u8,
x16: u8,
x17: u8,
x18: u8,
x19: u8,
x20: u8,
x21: u8,
x22: u8,
x23: u8,
x24: u8,
x25: u8,
x26: u8,
x27: u8,
x28: u8,
x29: u8,
x30: u8,
x31: u8
) -> Self
pub const fn new(
x0: u8,
x1: u8,
x2: u8,
x3: u8,
x4: u8,
x5: u8,
x6: u8,
x7: u8,
x8: u8,
x9: u8,
x10: u8,
x11: u8,
x12: u8,
x13: u8,
x14: u8,
x15: u8,
x16: u8,
x17: u8,
x18: u8,
x19: u8,
x20: u8,
x21: u8,
x22: u8,
x23: u8,
x24: u8,
x25: u8,
x26: u8,
x27: u8,
x28: u8,
x29: u8,
x30: u8,
x31: u8
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool
) -> Self
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
pub const fn new(
x0: i8,
x1: i8,
x2: i8,
x3: i8,
x4: i8,
x5: i8,
x6: i8,
x7: i8,
x8: i8,
x9: i8,
x10: i8,
x11: i8,
x12: i8,
x13: i8,
x14: i8,
x15: i8,
x16: i8,
x17: i8,
x18: i8,
x19: i8,
x20: i8,
x21: i8,
x22: i8,
x23: i8,
x24: i8,
x25: i8,
x26: i8,
x27: i8,
x28: i8,
x29: i8,
x30: i8,
x31: i8,
x32: i8,
x33: i8,
x34: i8,
x35: i8,
x36: i8,
x37: i8,
x38: i8,
x39: i8,
x40: i8,
x41: i8,
x42: i8,
x43: i8,
x44: i8,
x45: i8,
x46: i8,
x47: i8,
x48: i8,
x49: i8,
x50: i8,
x51: i8,
x52: i8,
x53: i8,
x54: i8,
x55: i8,
x56: i8,
x57: i8,
x58: i8,
x59: i8,
x60: i8,
x61: i8,
x62: i8,
x63: i8
) -> Self
pub const fn new(
x0: i8,
x1: i8,
x2: i8,
x3: i8,
x4: i8,
x5: i8,
x6: i8,
x7: i8,
x8: i8,
x9: i8,
x10: i8,
x11: i8,
x12: i8,
x13: i8,
x14: i8,
x15: i8,
x16: i8,
x17: i8,
x18: i8,
x19: i8,
x20: i8,
x21: i8,
x22: i8,
x23: i8,
x24: i8,
x25: i8,
x26: i8,
x27: i8,
x28: i8,
x29: i8,
x30: i8,
x31: i8,
x32: i8,
x33: i8,
x34: i8,
x35: i8,
x36: i8,
x37: i8,
x38: i8,
x39: i8,
x40: i8,
x41: i8,
x42: i8,
x43: i8,
x44: i8,
x45: i8,
x46: i8,
x47: i8,
x48: i8,
x49: i8,
x50: i8,
x51: i8,
x52: i8,
x53: i8,
x54: i8,
x55: i8,
x56: i8,
x57: i8,
x58: i8,
x59: i8,
x60: i8,
x61: i8,
x62: i8,
x63: i8
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: u8,
x1: u8,
x2: u8,
x3: u8,
x4: u8,
x5: u8,
x6: u8,
x7: u8,
x8: u8,
x9: u8,
x10: u8,
x11: u8,
x12: u8,
x13: u8,
x14: u8,
x15: u8,
x16: u8,
x17: u8,
x18: u8,
x19: u8,
x20: u8,
x21: u8,
x22: u8,
x23: u8,
x24: u8,
x25: u8,
x26: u8,
x27: u8,
x28: u8,
x29: u8,
x30: u8,
x31: u8,
x32: u8,
x33: u8,
x34: u8,
x35: u8,
x36: u8,
x37: u8,
x38: u8,
x39: u8,
x40: u8,
x41: u8,
x42: u8,
x43: u8,
x44: u8,
x45: u8,
x46: u8,
x47: u8,
x48: u8,
x49: u8,
x50: u8,
x51: u8,
x52: u8,
x53: u8,
x54: u8,
x55: u8,
x56: u8,
x57: u8,
x58: u8,
x59: u8,
x60: u8,
x61: u8,
x62: u8,
x63: u8
) -> Self
pub const fn new(
x0: u8,
x1: u8,
x2: u8,
x3: u8,
x4: u8,
x5: u8,
x6: u8,
x7: u8,
x8: u8,
x9: u8,
x10: u8,
x11: u8,
x12: u8,
x13: u8,
x14: u8,
x15: u8,
x16: u8,
x17: u8,
x18: u8,
x19: u8,
x20: u8,
x21: u8,
x22: u8,
x23: u8,
x24: u8,
x25: u8,
x26: u8,
x27: u8,
x28: u8,
x29: u8,
x30: u8,
x31: u8,
x32: u8,
x33: u8,
x34: u8,
x35: u8,
x36: u8,
x37: u8,
x38: u8,
x39: u8,
x40: u8,
x41: u8,
x42: u8,
x43: u8,
x44: u8,
x45: u8,
x46: u8,
x47: u8,
x48: u8,
x49: u8,
x50: u8,
x51: u8,
x52: u8,
x53: u8,
x54: u8,
x55: u8,
x56: u8,
x57: u8,
x58: u8,
x59: u8,
x60: u8,
x61: u8,
x62: u8,
x63: u8
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool,
x32: bool,
x33: bool,
x34: bool,
x35: bool,
x36: bool,
x37: bool,
x38: bool,
x39: bool,
x40: bool,
x41: bool,
x42: bool,
x43: bool,
x44: bool,
x45: bool,
x46: bool,
x47: bool,
x48: bool,
x49: bool,
x50: bool,
x51: bool,
x52: bool,
x53: bool,
x54: bool,
x55: bool,
x56: bool,
x57: bool,
x58: bool,
x59: bool,
x60: bool,
x61: bool,
x62: bool,
x63: bool
) -> Self
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool,
x32: bool,
x33: bool,
x34: bool,
x35: bool,
x36: bool,
x37: bool,
x38: bool,
x39: bool,
x40: bool,
x41: bool,
x42: bool,
x43: bool,
x44: bool,
x45: bool,
x46: bool,
x47: bool,
x48: bool,
x49: bool,
x50: bool,
x51: bool,
x52: bool,
x53: bool,
x54: bool,
x55: bool,
x56: bool,
x57: bool,
x58: bool,
x59: bool,
x60: bool,
x61: bool,
x62: bool,
x63: bool
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
pub const fn new(
x0: i16,
x1: i16,
x2: i16,
x3: i16,
x4: i16,
x5: i16,
x6: i16,
x7: i16,
x8: i16,
x9: i16,
x10: i16,
x11: i16,
x12: i16,
x13: i16,
x14: i16,
x15: i16,
x16: i16,
x17: i16,
x18: i16,
x19: i16,
x20: i16,
x21: i16,
x22: i16,
x23: i16,
x24: i16,
x25: i16,
x26: i16,
x27: i16,
x28: i16,
x29: i16,
x30: i16,
x31: i16
) -> Self
pub const fn new(
x0: i16,
x1: i16,
x2: i16,
x3: i16,
x4: i16,
x5: i16,
x6: i16,
x7: i16,
x8: i16,
x9: i16,
x10: i16,
x11: i16,
x12: i16,
x13: i16,
x14: i16,
x15: i16,
x16: i16,
x17: i16,
x18: i16,
x19: i16,
x20: i16,
x21: i16,
x22: i16,
x23: i16,
x24: i16,
x25: i16,
x26: i16,
x27: i16,
x28: i16,
x29: i16,
x30: i16,
x31: i16
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: u16,
x1: u16,
x2: u16,
x3: u16,
x4: u16,
x5: u16,
x6: u16,
x7: u16,
x8: u16,
x9: u16,
x10: u16,
x11: u16,
x12: u16,
x13: u16,
x14: u16,
x15: u16,
x16: u16,
x17: u16,
x18: u16,
x19: u16,
x20: u16,
x21: u16,
x22: u16,
x23: u16,
x24: u16,
x25: u16,
x26: u16,
x27: u16,
x28: u16,
x29: u16,
x30: u16,
x31: u16
) -> Self
pub const fn new(
x0: u16,
x1: u16,
x2: u16,
x3: u16,
x4: u16,
x5: u16,
x6: u16,
x7: u16,
x8: u16,
x9: u16,
x10: u16,
x11: u16,
x12: u16,
x13: u16,
x14: u16,
x15: u16,
x16: u16,
x17: u16,
x18: u16,
x19: u16,
x20: u16,
x21: u16,
x22: u16,
x23: u16,
x24: u16,
x25: u16,
x26: u16,
x27: u16,
x28: u16,
x29: u16,
x30: u16,
x31: u16
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool
) -> Self
pub const fn new(
x0: bool,
x1: bool,
x2: bool,
x3: bool,
x4: bool,
x5: bool,
x6: bool,
x7: bool,
x8: bool,
x9: bool,
x10: bool,
x11: bool,
x12: bool,
x13: bool,
x14: bool,
x15: bool,
x16: bool,
x17: bool,
x18: bool,
x19: bool,
x20: bool,
x21: bool,
x22: bool,
x23: bool,
x24: bool,
x25: bool,
x26: bool,
x27: bool,
x28: bool,
x29: bool,
x30: bool,
x31: bool
) -> Self
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Horizontal sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Horizontal product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If one of the vector element is NaN
the reduction returns
NaN
. The resulting NaN
is not required to be equal to any
of the NaN
s in the vector.
Largest vector element value.
Smallest vector element value.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Shuffle vector elements according to indices
.
Smallest positive normal value.
Negative infinity (-∞).
2/sqrt(π)
1/sqrt(2)
Fused multiply add estimate: ~= self * y + z
While fused multiply-add (fma
) has infinite precision,
mul_adde
has at worst the same precision of a multiply followed by an add.
This might be more efficient on architectures that do not have an fma
instruction.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Shifts the bits of each lane to the left by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the end of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Shifts the bits of each lane to the right by the specified
amount in the corresponding lane of n
, wrapping the
truncated bits to the beginning of the resulting integer.
Note: this is neither the same operation as <<
nor equivalent
to slice::rotate_left
.
Horizontal wrapping sum of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Horizontal wrapping product of the vector elements.
The intrinsic performs a tree-reduction of the vector elements. That is, for an 8 element vector:
((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7))
If an operation overflows it returns the mathematical result
modulo 2^n
where n
is the number of times it overflows.
Largest vector element value.
Smallest vector element value.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Reverses the byte order of the vector.
Converts self to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Converts self to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
Converts a vector from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
Returns the number of ones in the binary representation of
the lanes of self
.
Returns the number of zeros in the binary representation of
the lanes of self
.
Returns the number of leading zeros in the binary
representation of the lanes of self
.
Returns the number of trailing zeros in the binary
representation of the lanes of self
.
Shuffle vector elements according to indices
.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by
new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Lane-wise bitwise and
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Lane-wise bitwise or
of the vector elements.
Note: if the vector has one lane, the first element of the vector is returned.
Returns a wrapper that implements PartialOrd
.
Returns a wrapper that implements Ord
.
Shuffle vector elements according to indices
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Writes selected vector elements to memory.
Writes the lanes of values
for which the mask is true
to
their corresponding memory addresses in self
.
No memory is accessed for those lanes of self
whose mask
is
false
.
Overlapping memory addresses of self
are written to in order
from the lest-significant to the most-significant element.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Writes selected vector elements to memory.
Writes the lanes of values
for which the mask is true
to
their corresponding memory addresses in self
.
No memory is accessed for those lanes of self
whose mask
is
false
.
Overlapping memory addresses of self
are written to in order
from the lest-significant to the most-significant element.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Creates a new instance with each vector elements initialized with the provided values.
Constructs a new instance with each element initialized to
value
.
Returns a mask that selects those lanes that contain null
pointers.
Returns a new vector where the value at index
is replaced by
new_value
.
Panics
If index >= Self::lanes()
.
Returns a new vector where the value at index
is replaced by new_value
.
Safety
If index >= Self::lanes()
the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not aligned
to an align_of::<Self>()
boundary, the behavior is undefined.
Instantiates a new vector with the values of the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Writes the values of the vector to the slice
.
Panics
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
or &slice[0]
is not
aligned to an align_of::<Self>()
boundary, the behavior is
undefined.
Writes the values of the vector to the slice
.
Safety
If slice.len() < Self::lanes()
the behavior is undefined.
Calculates the offset from a pointer.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum, in bytes must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().offset(vec.len() as isize)
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
count
is in units of T
; e.g. a count of 3
represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is potentially hazardous to dereference (which requires unsafe).
Always use .offset(count)
instead when possible, because
offset allows the compiler to optimize better.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
This function is the inverse of offset.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and other pointer must be either in bounds or one byte past the end of the same allocated object.
-
The distance between the pointers, in bytes, cannot overflow an
isize
. -
The distance between the pointers, in bytes, must be an exact multiple of the size of
T
. -
The distance being in bounds cannot rely on “wrapping around” the address space.
The compiler and standard library generally try to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so ptr_into_vec.offset_from(vec.as_ptr())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset_from
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the distance between two pointers.
The returned value is in units of T
: the distance in bytes is
divided by mem::size_of::<T>()
.
If the address different between the two pointers is not a
multiple of mem::size_of::<T>()
then the result of the
division is rounded towards zero.
Though this method is safe for any two pointers, note that its result will be mostly useless if the two pointers aren’t into the same allocated object, for example if they point to two different local variables.
Calculates the offset from a pointer (convenience for
.offset(count as isize)
).
count
is in units of T
; e.g. a count of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset, in bytes, cannot overflow an
isize
. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a
usize
.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so vec.as_ptr().add(vec.len())
is always
safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table limitations or
splitting the address space. However, some 32-bit and 16-bit
platforms may successfully serve a request for more than
isize::MAX
bytes with things like Physical Address Extension.
As such, memory acquired directly from allocators or memory
mapped files may be too large to handle with this function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer (convenience for
.offset((count as isize).wrapping_neg())
).
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
If any of the following conditions are violated, the result is Undefined Behavior:
-
Both the starting and resulting pointer must be either in bounds or one byte past the end of an allocated object.
-
The computed offset cannot exceed
isize::MAX
bytes. -
The offset being in bounds cannot rely on “wrapping around” the address space. That is, the infinite-precision sum must fit in a usize.
The compiler and standard library generally tries to ensure
allocations never reach a size where an offset is a concern. For
instance, Vec
and Box
ensure they never allocate more than
isize::MAX
bytes, so
vec.as_ptr().add(vec.len()).sub(vec.len())
is always safe.
Most platforms fundamentally can’t even construct such an
allocation. For instance, no known 64-bit platform can ever
serve a request for 263 bytes due to page-table
limitations or splitting the address space. However, some 32-bit
and 16-bit platforms may successfully serve a request for more
than isize::MAX
bytes with things like Physical Address
Extension. As such, memory acquired directly from allocators or
memory mapped files may be too large to handle with this
function.
Consider using wrapping_offset
instead if these constraints
are difficult to satisfy. The only advantage of this method is
that it enables more aggressive compiler optimizations.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset(count as isize)
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .add(count)
instead when possible, because add
allows the compiler to optimize better.
Calculates the offset from a pointer using wrapping arithmetic.
(convenience for .wrapping_offset((count as isize).wrapping_sub())
)
count
is in units of T; e.g. a count
of 3 represents a
pointer offset of 3 * size_of::<T>()
bytes.
Safety
The resulting pointer does not need to be in bounds, but it is
potentially hazardous to dereference (which requires unsafe
).
Always use .sub(count)
instead when possible, because sub
allows the compiler to optimize better.
Shuffle vector elements according to indices
.
Reads selected vector elements from memory.
Instantiates a new vector by reading the values from self
for
those lanes whose mask
is true
, and using the elements of
value
otherwise.
No memory is accessed for those lanes of self
whose mask
is
false
.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Writes selected vector elements to memory.
Writes the lanes of values
for which the mask is true
to
their corresponding memory addresses in self
.
No memory is accessed for those lanes of self
whose mask
is
false
.
Overlapping memory addresses of self
are written to in order
from the lest-significant to the most-significant element.
Safety
This method is unsafe because it dereferences raw pointers. The
pointers must be aligned to mem::align_of::<T>()
.
Trait Implementations
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the +=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the &=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the |=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the ^=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the %=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the <<=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the >>=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more
Performs the -=
operation. Read more