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

impl Simd<[i8; 2]>[src]

pub const fn new(x0: i8, x1: i8) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i8; 2]>[src]

pub fn rotate_left(self, n: i8x2) -> i8x2[src]

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.

pub fn rotate_right(self, n: i8x2) -> i8x2[src]

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.

impl Simd<[i8; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i8; 2]>[src]

pub fn wrapping_sum(self) -> i8[src]

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.

pub fn wrapping_product(self) -> i8[src]

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.

impl Simd<[i8; 2]>[src]

pub fn max_element(self) -> i8[src]

Largest vector element value.

pub fn min_element(self) -> i8[src]

Smallest vector element value.

impl Simd<[i8; 2]>[src]

pub fn and(self) -> i8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i8; 2]>[src]

pub fn from_slice_aligned(slice: &[i8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i8; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i8; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i8; 2]>[src]

pub fn eq(self, other: Self) -> m8x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x2[src]

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

pub fn gt(self, other: Self) -> m8x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x2[src]

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

impl Simd<[i8; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i8x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i8; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i8x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[i8; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u8; 2]>[src]

pub const fn new(x0: u8, x1: u8) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u8; 2]>[src]

pub fn rotate_left(self, n: u8x2) -> u8x2[src]

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.

pub fn rotate_right(self, n: u8x2) -> u8x2[src]

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.

impl Simd<[u8; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u8; 2]>[src]

pub fn wrapping_sum(self) -> u8[src]

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.

pub fn wrapping_product(self) -> u8[src]

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.

impl Simd<[u8; 2]>[src]

pub fn max_element(self) -> u8[src]

Largest vector element value.

pub fn min_element(self) -> u8[src]

Smallest vector element value.

impl Simd<[u8; 2]>[src]

pub fn and(self) -> u8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u8; 2]>[src]

pub fn from_slice_aligned(slice: &[u8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u8; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u8; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u8; 2]>[src]

pub fn eq(self, other: Self) -> m8x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x2[src]

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

pub fn gt(self, other: Self) -> m8x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x2[src]

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

impl Simd<[u8; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u8x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u8; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u8x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[u8; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m8; 2]>[src]

pub const fn new(x0: bool, x1: bool) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m8; 2]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m8; 2]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m8; 2]>[src]

pub fn eq(self, other: Self) -> m8x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x2[src]

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

pub fn gt(self, other: Self) -> m8x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x2[src]

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

impl Simd<[m8; 2]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m8; 2] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m8; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m8x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m8; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m8x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[m8; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m8; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i8; 4]>[src]

pub const fn new(x0: i8, x1: i8, x2: i8, x3: i8) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i8; 4]>[src]

pub fn rotate_left(self, n: i8x4) -> i8x4[src]

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.

pub fn rotate_right(self, n: i8x4) -> i8x4[src]

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.

impl Simd<[i8; 4]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i8; 4]>[src]

pub fn wrapping_sum(self) -> i8[src]

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.

pub fn wrapping_product(self) -> i8[src]

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.

impl Simd<[i8; 4]>[src]

pub fn max_element(self) -> i8[src]

Largest vector element value.

pub fn min_element(self) -> i8[src]

Smallest vector element value.

impl Simd<[i8; 4]>[src]

pub fn and(self) -> i8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i8; 4]>[src]

pub fn from_slice_aligned(slice: &[i8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 4]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 4]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i8; 4]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i8; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i8; 4]>[src]

pub fn eq(self, other: Self) -> m8x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x4[src]

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

pub fn gt(self, other: Self) -> m8x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x4[src]

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

impl Simd<[i8; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i8x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i8; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i8x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[i8; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u8; 4]>[src]

pub const fn new(x0: u8, x1: u8, x2: u8, x3: u8) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u8; 4]>[src]

pub fn rotate_left(self, n: u8x4) -> u8x4[src]

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.

pub fn rotate_right(self, n: u8x4) -> u8x4[src]

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.

impl Simd<[u8; 4]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u8; 4]>[src]

pub fn wrapping_sum(self) -> u8[src]

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.

pub fn wrapping_product(self) -> u8[src]

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.

impl Simd<[u8; 4]>[src]

pub fn max_element(self) -> u8[src]

Largest vector element value.

pub fn min_element(self) -> u8[src]

Smallest vector element value.

impl Simd<[u8; 4]>[src]

pub fn and(self) -> u8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u8; 4]>[src]

pub fn from_slice_aligned(slice: &[u8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 4]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 4]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u8; 4]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u8; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u8; 4]>[src]

pub fn eq(self, other: Self) -> m8x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x4[src]

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

pub fn gt(self, other: Self) -> m8x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x4[src]

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

impl Simd<[u8; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u8x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u8; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u8x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[u8; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m8; 4]>[src]

pub const fn new(x0: bool, x1: bool, x2: bool, x3: bool) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m8; 4]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m8; 4]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m8; 4]>[src]

pub fn eq(self, other: Self) -> m8x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x4[src]

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

pub fn gt(self, other: Self) -> m8x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x4[src]

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

impl Simd<[m8; 4]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m8; 4] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m8; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m8x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m8; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m8x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[m8; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m8; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i16; 2]>[src]

pub const fn new(x0: i16, x1: i16) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i16; 2]>[src]

pub fn rotate_left(self, n: i16x2) -> i16x2[src]

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.

pub fn rotate_right(self, n: i16x2) -> i16x2[src]

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.

impl Simd<[i16; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i16; 2]>[src]

pub fn wrapping_sum(self) -> i16[src]

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.

pub fn wrapping_product(self) -> i16[src]

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.

impl Simd<[i16; 2]>[src]

pub fn max_element(self) -> i16[src]

Largest vector element value.

pub fn min_element(self) -> i16[src]

Smallest vector element value.

impl Simd<[i16; 2]>[src]

pub fn and(self) -> i16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i16; 2]>[src]

pub fn from_slice_aligned(slice: &[i16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i16; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i16; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i16; 2]>[src]

pub fn eq(self, other: Self) -> m16x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x2[src]

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

pub fn gt(self, other: Self) -> m16x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x2[src]

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

impl Simd<[i16; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i16x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i16; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i16x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[i16; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u16; 2]>[src]

pub const fn new(x0: u16, x1: u16) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u16; 2]>[src]

pub fn rotate_left(self, n: u16x2) -> u16x2[src]

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.

pub fn rotate_right(self, n: u16x2) -> u16x2[src]

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.

impl Simd<[u16; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u16; 2]>[src]

pub fn wrapping_sum(self) -> u16[src]

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.

pub fn wrapping_product(self) -> u16[src]

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.

impl Simd<[u16; 2]>[src]

pub fn max_element(self) -> u16[src]

Largest vector element value.

pub fn min_element(self) -> u16[src]

Smallest vector element value.

impl Simd<[u16; 2]>[src]

pub fn and(self) -> u16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u16; 2]>[src]

pub fn from_slice_aligned(slice: &[u16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u16; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u16; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u16; 2]>[src]

pub fn eq(self, other: Self) -> m16x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x2[src]

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

pub fn gt(self, other: Self) -> m16x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x2[src]

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

impl Simd<[u16; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u16x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u16; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u16x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[u16; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m16; 2]>[src]

pub const fn new(x0: bool, x1: bool) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m16; 2]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m16; 2]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m16; 2]>[src]

pub fn eq(self, other: Self) -> m16x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x2[src]

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

pub fn gt(self, other: Self) -> m16x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x2[src]

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

impl Simd<[m16; 2]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m16; 2] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m16; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m16x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m16; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m16x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[m16; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m16; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i8; 8]>[src]

pub const fn new(
    x0: i8,
    x1: i8,
    x2: i8,
    x3: i8,
    x4: i8,
    x5: i8,
    x6: i8,
    x7: i8
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i8; 8]>[src]

pub fn rotate_left(self, n: i8x8) -> i8x8[src]

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.

pub fn rotate_right(self, n: i8x8) -> i8x8[src]

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.

impl Simd<[i8; 8]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i8; 8]>[src]

pub fn wrapping_sum(self) -> i8[src]

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.

pub fn wrapping_product(self) -> i8[src]

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.

impl Simd<[i8; 8]>[src]

pub fn max_element(self) -> i8[src]

Largest vector element value.

pub fn min_element(self) -> i8[src]

Smallest vector element value.

impl Simd<[i8; 8]>[src]

pub fn and(self) -> i8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i8; 8]>[src]

pub fn from_slice_aligned(slice: &[i8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 8]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 8]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i8; 8]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i8; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i8; 8]>[src]

pub fn eq(self, other: Self) -> m8x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x8[src]

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

pub fn gt(self, other: Self) -> m8x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x8[src]

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

impl Simd<[i8; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i8x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i8; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i8x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[i8; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u8; 8]>[src]

pub const fn new(
    x0: u8,
    x1: u8,
    x2: u8,
    x3: u8,
    x4: u8,
    x5: u8,
    x6: u8,
    x7: u8
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u8; 8]>[src]

pub fn rotate_left(self, n: u8x8) -> u8x8[src]

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.

pub fn rotate_right(self, n: u8x8) -> u8x8[src]

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.

impl Simd<[u8; 8]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u8; 8]>[src]

pub fn wrapping_sum(self) -> u8[src]

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.

pub fn wrapping_product(self) -> u8[src]

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.

impl Simd<[u8; 8]>[src]

pub fn max_element(self) -> u8[src]

Largest vector element value.

pub fn min_element(self) -> u8[src]

Smallest vector element value.

impl Simd<[u8; 8]>[src]

pub fn and(self) -> u8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u8; 8]>[src]

pub fn from_slice_aligned(slice: &[u8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 8]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 8]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u8; 8]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u8; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u8; 8]>[src]

pub fn eq(self, other: Self) -> m8x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x8[src]

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

pub fn gt(self, other: Self) -> m8x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x8[src]

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

impl Simd<[u8; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u8x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u8; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u8x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[u8; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m8; 8]>[src]

pub const fn new(
    x0: bool,
    x1: bool,
    x2: bool,
    x3: bool,
    x4: bool,
    x5: bool,
    x6: bool,
    x7: bool
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m8; 8]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m8; 8]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m8; 8]>[src]

pub fn eq(self, other: Self) -> m8x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x8[src]

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

pub fn gt(self, other: Self) -> m8x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x8[src]

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

impl Simd<[m8; 8]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m8; 8] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m8; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m8x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m8; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m8x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[m8; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m8; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i16; 4]>[src]

pub const fn new(x0: i16, x1: i16, x2: i16, x3: i16) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i16; 4]>[src]

pub fn rotate_left(self, n: i16x4) -> i16x4[src]

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.

pub fn rotate_right(self, n: i16x4) -> i16x4[src]

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.

impl Simd<[i16; 4]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i16; 4]>[src]

pub fn wrapping_sum(self) -> i16[src]

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.

pub fn wrapping_product(self) -> i16[src]

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.

impl Simd<[i16; 4]>[src]

pub fn max_element(self) -> i16[src]

Largest vector element value.

pub fn min_element(self) -> i16[src]

Smallest vector element value.

impl Simd<[i16; 4]>[src]

pub fn and(self) -> i16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i16; 4]>[src]

pub fn from_slice_aligned(slice: &[i16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 4]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 4]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i16; 4]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i16; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i16; 4]>[src]

pub fn eq(self, other: Self) -> m16x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x4[src]

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

pub fn gt(self, other: Self) -> m16x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x4[src]

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

impl Simd<[i16; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i16x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i16; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i16x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[i16; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u16; 4]>[src]

pub const fn new(x0: u16, x1: u16, x2: u16, x3: u16) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u16; 4]>[src]

pub fn rotate_left(self, n: u16x4) -> u16x4[src]

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.

pub fn rotate_right(self, n: u16x4) -> u16x4[src]

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.

impl Simd<[u16; 4]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u16; 4]>[src]

pub fn wrapping_sum(self) -> u16[src]

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.

pub fn wrapping_product(self) -> u16[src]

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.

impl Simd<[u16; 4]>[src]

pub fn max_element(self) -> u16[src]

Largest vector element value.

pub fn min_element(self) -> u16[src]

Smallest vector element value.

impl Simd<[u16; 4]>[src]

pub fn and(self) -> u16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u16; 4]>[src]

pub fn from_slice_aligned(slice: &[u16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 4]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 4]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u16; 4]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u16; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u16; 4]>[src]

pub fn eq(self, other: Self) -> m16x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x4[src]

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

pub fn gt(self, other: Self) -> m16x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x4[src]

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

impl Simd<[u16; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u16x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u16; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u16x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[u16; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m16; 4]>[src]

pub const fn new(x0: bool, x1: bool, x2: bool, x3: bool) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m16; 4]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m16; 4]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m16; 4]>[src]

pub fn eq(self, other: Self) -> m16x4[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x4[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x4[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x4[src]

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

pub fn gt(self, other: Self) -> m16x4[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x4[src]

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

impl Simd<[m16; 4]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m16; 4] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m16; 4]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m16x4>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m16; 4]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m16x4>[src]

Returns a wrapper that implements Ord.

impl Simd<[m16; 4]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m16; 4]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i32; 2]>[src]

pub const fn new(x0: i32, x1: i32) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i32) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i32[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i32[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i32; 2]>[src]

pub fn rotate_left(self, n: i32x2) -> i32x2[src]

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.

pub fn rotate_right(self, n: i32x2) -> i32x2[src]

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.

impl Simd<[i32; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i32; 2]>[src]

pub fn wrapping_sum(self) -> i32[src]

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.

pub fn wrapping_product(self) -> i32[src]

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.

impl Simd<[i32; 2]>[src]

pub fn max_element(self) -> i32[src]

Largest vector element value.

pub fn min_element(self) -> i32[src]

Smallest vector element value.

impl Simd<[i32; 2]>[src]

pub fn and(self) -> i32[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i32[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i32[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i32; 2]>[src]

pub fn from_slice_aligned(slice: &[i32]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i32]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i32; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i32])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i32])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i32])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i32])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i32; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i32; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i32; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i32; 2]>[src]

pub fn eq(self, other: Self) -> m32x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m32x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m32x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m32x2[src]

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

pub fn gt(self, other: Self) -> m32x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m32x2[src]

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

impl Simd<[i32; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i32x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i32; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i32x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[i32; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u32; 2]>[src]

pub const fn new(x0: u32, x1: u32) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u32) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u32[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u32[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u32; 2]>[src]

pub fn rotate_left(self, n: u32x2) -> u32x2[src]

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.

pub fn rotate_right(self, n: u32x2) -> u32x2[src]

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.

impl Simd<[u32; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u32; 2]>[src]

pub fn wrapping_sum(self) -> u32[src]

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.

pub fn wrapping_product(self) -> u32[src]

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.

impl Simd<[u32; 2]>[src]

pub fn max_element(self) -> u32[src]

Largest vector element value.

pub fn min_element(self) -> u32[src]

Smallest vector element value.

impl Simd<[u32; 2]>[src]

pub fn and(self) -> u32[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u32[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u32[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u32; 2]>[src]

pub fn from_slice_aligned(slice: &[u32]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u32]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u32; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u32])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u32])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u32])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u32])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u32; 2]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u32; 2]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u32; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u32; 2]>[src]

pub fn eq(self, other: Self) -> m32x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m32x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m32x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m32x2[src]

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

pub fn gt(self, other: Self) -> m32x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m32x2[src]

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

impl Simd<[u32; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u32x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u32; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u32x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[u32; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m32; 2]>[src]

pub const fn new(x0: bool, x1: bool) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m32; 2]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m32; 2]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m32; 2]>[src]

pub fn eq(self, other: Self) -> m32x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m32x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m32x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m32x2[src]

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

pub fn gt(self, other: Self) -> m32x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m32x2[src]

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

impl Simd<[m32; 2]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m32; 2] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m32; 2]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m32x2>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m32; 2]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m32x2>[src]

Returns a wrapper that implements Ord.

impl Simd<[m32; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m32; 2]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[f32; 2]>[src]

pub const fn new(x0: f32, x1: f32) -> Self[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: f32) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> f32[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> f32[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: f32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: f32) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[f32; 2]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[f32; 2]>[src]

pub fn sum(self) -> f32[src]

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.

pub fn product(self) -> f32[src]

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.

impl Simd<[f32; 2]>[src]

pub fn max_element(self) -> f32[src]

Largest vector element value.

pub fn min_element(self) -> f32[src]

Smallest vector element value.

impl Simd<[f32; 2]>[src]

pub fn from_slice_aligned(slice: &[f32]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[f32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[f32]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[f32]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[f32; 2]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [f32])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [f32])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [f32])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [f32])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[f32; 2]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[f32; 2]>[src]

pub const EPSILON: f32x2[src]

Machine epsilon value.

pub const MIN: f32x2[src]

Smallest finite value.

pub const MIN_POSITIVE: f32x2[src]

Smallest positive normal value.

pub const MAX: f32x2[src]

Largest finite value.

pub const NAN: f32x2[src]

Not a Number (NaN).

pub const INFINITY: f32x2[src]

Infinity (∞).

pub const NEG_INFINITY: f32x2[src]

Negative infinity (-∞).

pub const PI: f32x2[src]

Archimedes’ constant (π)

pub const FRAC_PI_2: f32x2[src]

π/2

pub const FRAC_PI_3: f32x2[src]

π/3

pub const FRAC_PI_4: f32x2[src]

π/4

pub const FRAC_PI_6: f32x2[src]

π/6

pub const FRAC_PI_8: f32x2[src]

π/8

pub const FRAC_1_PI: f32x2[src]

1/π

pub const FRAC_2_PI: f32x2[src]

2/π

pub const FRAC_2_SQRT_PI: f32x2[src]

2/sqrt(π)

pub const SQRT_2: f32x2[src]

sqrt(2)

pub const FRAC_1_SQRT_2: f32x2[src]

1/sqrt(2)

pub const E: f32x2[src]

Euler’s number (e)

pub const LOG2_E: f32x2[src]

log2(e)

pub const LOG10_E: f32x2[src]

log10(e)

pub const LN_2: f32x2[src]

ln(2)

pub const LN_10: f32x2[src]

ln(10)

impl Simd<[f32; 2]>[src]

pub fn is_nan(self) -> m32x2[src]

pub fn is_infinite(self) -> m32x2[src]

pub fn is_finite(self) -> m32x2[src]

impl Simd<[f32; 2]>[src]

pub fn abs(self) -> Self[src]

Absolute value.

impl Simd<[f32; 2]>[src]

pub fn cos(self) -> Self[src]

Cosine.

pub fn cos_pi(self) -> Self[src]

Cosine of self * PI.

impl Simd<[f32; 2]>[src]

pub fn exp(self) -> Self[src]

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

impl Simd<[f32; 2]>[src]

pub fn ln(self) -> Self[src]

Returns the natural logarithm of self.

impl Simd<[f32; 2]>[src]

pub fn mul_add(self, y: Self, z: Self) -> Self[src]

Fused multiply add: self * y + z

impl Simd<[f32; 2]>[src]

pub fn mul_adde(self, y: Self, z: Self) -> Self[src]

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.

impl Simd<[f32; 2]>[src]

pub fn powf(self, x: Self) -> Self[src]

Raises self number to the floating point power of x.

impl Simd<[f32; 2]>[src]

pub fn recpre(self) -> Self[src]

Reciprocal estimate: ~= 1. / self.

FIXME: The precision of the estimate is currently unspecified.

impl Simd<[f32; 2]>[src]

pub fn rsqrte(self) -> Self[src]

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

FIXME: The precision of the estimate is currently unspecified.

impl Simd<[f32; 2]>[src]

pub fn sin(self) -> Self[src]

Sine.

pub fn sin_pi(self) -> Self[src]

Sine of self * PI.

pub fn sin_cos_pi(self) -> (Self, Self)[src]

Sine and cosine of self * PI.

impl Simd<[f32; 2]>[src]

pub fn sqrt(self) -> Self[src]

impl Simd<[f32; 2]>[src]

pub fn sqrte(self) -> Self[src]

Square-root estimate.

FIXME: The precision of the estimate is currently unspecified.

impl Simd<[f32; 2]>[src]

pub fn tanh(self) -> Self[src]

Tanh.

impl Simd<[f32; 2]>[src]

pub fn eq(self, other: Self) -> m32x2[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m32x2[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m32x2[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m32x2[src]

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

pub fn gt(self, other: Self) -> m32x2[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m32x2[src]

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

impl Simd<[i8; 16]>[src]

pub const fn new(
    x0: i8,
    x1: i8,
    x2: i8,
    x3: i8,
    x4: i8,
    x5: i8,
    x6: i8,
    x7: i8,
    x8: i8,
    x9: i8,
    x10: i8,
    x11: i8,
    x12: i8,
    x13: i8,
    x14: i8,
    x15: i8
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i8; 16]>[src]

pub fn rotate_left(self, n: i8x16) -> i8x16[src]

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.

pub fn rotate_right(self, n: i8x16) -> i8x16[src]

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.

impl Simd<[i8; 16]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i8; 16]>[src]

pub fn wrapping_sum(self) -> i8[src]

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.

pub fn wrapping_product(self) -> i8[src]

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.

impl Simd<[i8; 16]>[src]

pub fn max_element(self) -> i8[src]

Largest vector element value.

pub fn min_element(self) -> i8[src]

Smallest vector element value.

impl Simd<[i8; 16]>[src]

pub fn and(self) -> i8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i8; 16]>[src]

pub fn from_slice_aligned(slice: &[i8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 16]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i8; 16]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i8; 16]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i8; 16]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i8; 16]>[src]

pub fn eq(self, other: Self) -> m8x16[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x16[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x16[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x16[src]

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

pub fn gt(self, other: Self) -> m8x16[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x16[src]

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

impl Simd<[i8; 16]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i8x16>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i8; 16]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i8x16>[src]

Returns a wrapper that implements Ord.

impl Simd<[i8; 16]>[src]

pub fn bitmask(self) -> u16[src]

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.

impl Simd<[u8; 16]>[src]

pub const fn new(
    x0: u8,
    x1: u8,
    x2: u8,
    x3: u8,
    x4: u8,
    x5: u8,
    x6: u8,
    x7: u8,
    x8: u8,
    x9: u8,
    x10: u8,
    x11: u8,
    x12: u8,
    x13: u8,
    x14: u8,
    x15: u8
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u8) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u8[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u8[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u8) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u8; 16]>[src]

pub fn rotate_left(self, n: u8x16) -> u8x16[src]

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.

pub fn rotate_right(self, n: u8x16) -> u8x16[src]

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.

impl Simd<[u8; 16]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u8; 16]>[src]

pub fn wrapping_sum(self) -> u8[src]

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.

pub fn wrapping_product(self) -> u8[src]

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.

impl Simd<[u8; 16]>[src]

pub fn max_element(self) -> u8[src]

Largest vector element value.

pub fn min_element(self) -> u8[src]

Smallest vector element value.

impl Simd<[u8; 16]>[src]

pub fn and(self) -> u8[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u8[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u8[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u8; 16]>[src]

pub fn from_slice_aligned(slice: &[u8]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u8]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u8]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 16]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u8])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u8])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u8])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u8; 16]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u8; 16]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u8; 16]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u8; 16]>[src]

pub fn eq(self, other: Self) -> m8x16[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x16[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x16[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x16[src]

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

pub fn gt(self, other: Self) -> m8x16[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x16[src]

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

impl Simd<[u8; 16]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u8x16>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u8; 16]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u8x16>[src]

Returns a wrapper that implements Ord.

impl Simd<[u8; 16]>[src]

pub fn bitmask(self) -> u16[src]

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.

impl Simd<[m8; 16]>[src]

pub const fn new(
    x0: bool,
    x1: bool,
    x2: bool,
    x3: bool,
    x4: bool,
    x5: bool,
    x6: bool,
    x7: bool,
    x8: bool,
    x9: bool,
    x10: bool,
    x11: bool,
    x12: bool,
    x13: bool,
    x14: bool,
    x15: bool
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m8; 16]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m8; 16]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m8; 16]>[src]

pub fn eq(self, other: Self) -> m8x16[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m8x16[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m8x16[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m8x16[src]

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

pub fn gt(self, other: Self) -> m8x16[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m8x16[src]

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

impl Simd<[m8; 16]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m8; 16] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m8; 16]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m8x16>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m8; 16]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m8x16>[src]

Returns a wrapper that implements Ord.

impl Simd<[m8; 16]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m8; 16]>[src]

pub fn bitmask(self) -> u16[src]

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.

impl Simd<[i16; 8]>[src]

pub const fn new(
    x0: i16,
    x1: i16,
    x2: i16,
    x3: i16,
    x4: i16,
    x5: i16,
    x6: i16,
    x7: i16
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: i16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> i16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> i16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: i16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[i16; 8]>[src]

pub fn rotate_left(self, n: i16x8) -> i16x8[src]

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.

pub fn rotate_right(self, n: i16x8) -> i16x8[src]

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.

impl Simd<[i16; 8]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[i16; 8]>[src]

pub fn wrapping_sum(self) -> i16[src]

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.

pub fn wrapping_product(self) -> i16[src]

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.

impl Simd<[i16; 8]>[src]

pub fn max_element(self) -> i16[src]

Largest vector element value.

pub fn min_element(self) -> i16[src]

Smallest vector element value.

impl Simd<[i16; 8]>[src]

pub fn and(self) -> i16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> i16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> i16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[i16; 8]>[src]

pub fn from_slice_aligned(slice: &[i16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[i16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[i16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 8]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [i16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [i16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [i16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[i16; 8]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[i16; 8]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[i16; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[i16; 8]>[src]

pub fn eq(self, other: Self) -> m16x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x8[src]

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

pub fn gt(self, other: Self) -> m16x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x8[src]

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

impl Simd<[i16; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<i16x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[i16; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<i16x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[i16; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[u16; 8]>[src]

pub const fn new(
    x0: u16,
    x1: u16,
    x2: u16,
    x3: u16,
    x4: u16,
    x5: u16,
    x6: u16,
    x7: u16
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: u16) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> u16[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> u16[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: u16) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[u16; 8]>[src]

pub fn rotate_left(self, n: u16x8) -> u16x8[src]

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.

pub fn rotate_right(self, n: u16x8) -> u16x8[src]

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.

impl Simd<[u16; 8]>[src]

pub fn min(self, x: Self) -> Self[src]

Minimum of two vectors.

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

pub fn max(self, x: Self) -> Self[src]

Maximum of two vectors.

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

impl Simd<[u16; 8]>[src]

pub fn wrapping_sum(self) -> u16[src]

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.

pub fn wrapping_product(self) -> u16[src]

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.

impl Simd<[u16; 8]>[src]

pub fn max_element(self) -> u16[src]

Largest vector element value.

pub fn min_element(self) -> u16[src]

Smallest vector element value.

impl Simd<[u16; 8]>[src]

pub fn and(self) -> u16[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> u16[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> u16[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[u16; 8]>[src]

pub fn from_slice_aligned(slice: &[u16]) -> Self[src]

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.

pub fn from_slice_unaligned(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Panics

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

pub unsafe fn from_slice_aligned_unchecked(slice: &[u16]) -> Self[src]

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.

pub unsafe fn from_slice_unaligned_unchecked(slice: &[u16]) -> Self[src]

Instantiates a new vector with the values of the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 8]>[src]

pub fn write_to_slice_aligned(self, slice: &mut [u16])[src]

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.

pub fn write_to_slice_unaligned(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Panics

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

pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [u16])[src]

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.

pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [u16])[src]

Writes the values of the vector to the slice.

Safety

If slice.len() < Self::lanes() the behavior is undefined.

impl Simd<[u16; 8]>[src]

pub fn swap_bytes(self) -> Self[src]

Reverses the byte order of the vector.

pub fn to_le(self) -> Self[src]

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.

pub fn to_be(self) -> Self[src]

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.

pub fn from_le(x: Self) -> Self[src]

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.

pub fn from_be(x: Self) -> Self[src]

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.

impl Simd<[u16; 8]>[src]

pub fn count_ones(self) -> Self[src]

Returns the number of ones in the binary representation of the lanes of self.

pub fn count_zeros(self) -> Self[src]

Returns the number of zeros in the binary representation of the lanes of self.

pub fn leading_zeros(self) -> Self[src]

Returns the number of leading zeros in the binary representation of the lanes of self.

pub fn trailing_zeros(self) -> Self[src]

Returns the number of trailing zeros in the binary representation of the lanes of self.

impl Simd<[u16; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[u16; 8]>[src]

pub fn eq(self, other: Self) -> m16x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x8[src]

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

pub fn gt(self, other: Self) -> m16x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x8[src]

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

impl Simd<[u16; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<u16x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[u16; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<u16x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[u16; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[m16; 8]>[src]

pub const fn new(
    x0: bool,
    x1: bool,
    x2: bool,
    x3: bool,
    x4: bool,
    x5: bool,
    x6: bool,
    x7: bool
) -> Self
[src]

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

pub const fn lanes() -> usize[src]

Returns the number of vector lanes.

pub const fn splat(value: bool) -> Self[src]

Constructs a new instance with each element initialized to value.

pub fn extract(self, index: usize) -> bool[src]

Extracts the value at index.

Panics

If index >= Self::lanes().

pub unsafe fn extract_unchecked(self, index: usize) -> bool[src]

Extracts the value at index.

Safety

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

#[must_use = "replace does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub fn replace(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Panics

If index >= Self::lanes().

#[must_use = "replace_unchecked does not modify the original value - \ it returns a new vector with the value at `index` \ replaced by `new_value`d"]
pub unsafe fn replace_unchecked(self, index: usize, new_value: bool) -> Self
[src]

Returns a new vector where the value at index is replaced by new_value.

Safety

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

impl Simd<[m16; 8]>[src]

pub fn and(self) -> bool[src]

Lane-wise bitwise and of the vector elements.

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

pub fn or(self) -> bool[src]

Lane-wise bitwise or of the vector elements.

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

pub fn xor(self) -> bool[src]

Lane-wise bitwise xor of the vector elements.

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

impl Simd<[m16; 8]>[src]

pub fn all(self) -> bool[src]

Are all vector lanes true?

pub fn any(self) -> bool[src]

Is any vector lane true?

pub fn none(self) -> bool[src]

Are all vector lanes false?

impl Simd<[m16; 8]>[src]

pub fn eq(self, other: Self) -> m16x8[src]

Lane-wise equality comparison.

pub fn ne(self, other: Self) -> m16x8[src]

Lane-wise inequality comparison.

pub fn lt(self, other: Self) -> m16x8[src]

Lane-wise less-than comparison.

pub fn le(self, other: Self) -> m16x8[src]

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

pub fn gt(self, other: Self) -> m16x8[src]

Lane-wise greater-than comparison.

pub fn ge(self, other: Self) -> m16x8[src]

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

impl Simd<[m16; 8]>[src]

pub fn select<T>(self, a: Simd<T>, b: Simd<T>) -> Simd<T> where
    T: SimdArray<NT = <[m16; 8] as SimdArray>::NT>, 
[src]

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.

impl Simd<[m16; 8]>[src]

pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<m16x8>[src]

Returns a wrapper that implements PartialOrd.

impl Simd<[m16; 8]>[src]

pub fn lex_ord(&self) -> LexicographicallyOrdered<m16x8>[src]

Returns a wrapper that implements Ord.

impl Simd<[m16; 8]>[src]

pub fn shuffle1_dyn<I>(self, indices: I) -> Self where
    Self: Shuffle1Dyn<Indices = I>, 
[src]

Shuffle vector elements according to indices.

impl Simd<[m16; 8]>[src]

pub fn bitmask(self) -> u8[src]

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.

impl Simd<[i32; 4]>[src]

pub const fn new(x0: i32, x1: i32, x2: i32, x3: i32) -> Self