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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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 NaNs 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 NaNs 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Machine epsilon value.

Smallest finite value.

Smallest positive normal value.

Largest finite value.

Not a Number (NaN).

Infinity (∞).

Negative infinity (-∞).

Archimedes’ constant (π)

π/2

π/3

π/4

π/6

π/8

1/π

2/π

2/sqrt(π)

sqrt(2)

1/sqrt(2)

Euler’s number (e)

log2(e)

log10(e)

ln(2)

ln(10)

Absolute value.

Cosine.

Cosine of self * PI.

Returns the exponential function of self: e^(self).

Returns the natural logarithm of self.

Fused multiply add: self * y + z

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.

Raises self number to the floating point power of x.

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

Reciprocal square-root estimate: ~= 1. / self.sqrt().

FIXME: The precision of the estimate is currently unspecified.

Sine.

Sine of self * PI.

Sine and cosine of self * PI.

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

Tanh.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Minimum of two vectors.

Returns a new vector containing the minimum value of each of the input vector lanes.

Maximum of two vectors.

Returns a new vector containing the maximum value of each of the input vector lanes.

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.

Lane-wise bitwise xor 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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Converts a vector from big endian to the target’s endianness.

On big endian this is a no-op. On little 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.

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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.

Lane-wise bitwise xor of the vector elements.

Note: if the vector has one lane, the first element of the vector is returned.

Are all vector lanes true?

Is any vector lane true?

Are all vector lanes false?

Lane-wise equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

Selects elements of a and b using mask.

The lanes of the result for which the mask is true contain the values of a. The remaining lanes contain the values of b.

Returns a wrapper that implements PartialOrd.

Returns a wrapper that implements Ord.

Shuffle vector elements according to indices.

Creates a bitmask with the MSB of each vector lane.

If the vector has less than 8 lanes, the bits that do not correspond to any vector lanes are cleared.

Creates a new instance with each vector elements initialized with the provided values.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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.

Returns the number of vector lanes.

Constructs a new instance with each element initialized to value.

Constructs a new instance with each element initialized to null.

Returns a mask that selects those lanes that contain null pointers.

Extracts the value at index.

Panics

If index >= Self::lanes().

Extracts the value at index.

Safety

If index >= Self::lanes() the behavior is undefined.

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 equality comparison.

Lane-wise inequality comparison.

Lane-wise less-than comparison.

Lane-wise less-than-or-equals comparison.

Lane-wise greater-than comparison.

Lane-wise greater-than-or-equals comparison.

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.

Panics

If slice.len() < Self::lanes().

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.

Panics

If slice.len() < Self::lanes().

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

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

The resulting type after applying the + operator.

Performs the + operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

Performs the += operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

The resulting type after applying the & operator.

Performs the & operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

Performs the &= operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

The resulting type after applying the | operator.

Performs the | operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

Performs the |= operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Performs the ^= operation. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

The resulting type after applying the / operator.

Performs the / operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the /= operation. Read more

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Performs the conversion.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

Numeric cast from T to Self.

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

The resulting type after applying the * operator.

Performs the * operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

Performs the *= operation. Read more

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

This method tests for self and other values to be equal, and is used by ==. Read more

This method tests for !=.

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

Method which takes an iterator and generates Self from the elements by multiplying the items. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

The resulting type after applying the % operator.

Performs the % operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

Performs the %= operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

The resulting type after applying the << operator.

Performs the << operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

Performs the <<= operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

The resulting type after applying the >> operator.

Performs the >> operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

Performs the >>= operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

The resulting type after applying the - operator.

Performs the - operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Performs the -= operation. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Method which takes an iterator and generates Self from the elements by “summing up” the items. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.