Type Alias creusot_contracts::std::simd::prelude::f64x64

source ·
pub type f64x64 = Simd<f64, 64>;
🔬This is a nightly-only experimental API. (portable_simd)
Expand description

A SIMD vector with 64 elements of type f64.

Aliased Type§

struct f64x64(/* private fields */);

Implementations

source§

impl<T, const N: usize> Simd<T, N>

source

pub fn reverse(self) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reverse the order of the elements in the vector.

source

pub fn rotate_elements_left<const OFFSET: usize>(self) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Rotates the vector such that the first OFFSET elements of the slice move to the end while the last self.len() - OFFSET elements move to the front. After calling rotate_elements_left, the element previously at index OFFSET will become the first element in the slice.

source

pub fn rotate_elements_right<const OFFSET: usize>(self) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Rotates the vector such that the first self.len() - OFFSET elements of the vector move to the end while the last OFFSET elements move to the front. After calling rotate_elements_right, the element previously at index self.len() - OFFSET will become the first element in the slice.

source

pub fn interleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)

🔬This is a nightly-only experimental API. (portable_simd)

Interleave two vectors.

The resulting vectors contain elements taken alternatively from self and other, first filling the first result, and then the second.

The reverse of this operation is Simd::deinterleave.

let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);
source

pub fn deinterleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)

🔬This is a nightly-only experimental API. (portable_simd)

Deinterleave two vectors.

The first result takes every other element of self and then other, starting with the first element.

The second result takes every other element of self and then other, starting with the second element.

The reverse of this operation is Simd::interleave.

let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);
source

pub fn resize<const M: usize>(self, value: T) -> Simd<T, M>

🔬This is a nightly-only experimental API. (portable_simd)

Resize a vector.

If M > N, extends the length of a vector, setting the new elements to value. If M < N, truncates the vector to the first M elements.

let x = u32x4::from_array([0, 1, 2, 3]);
assert_eq!(x.resize::<8>(9).to_array(), [0, 1, 2, 3, 9, 9, 9, 9]);
assert_eq!(x.resize::<2>(9).to_array(), [0, 1]);
source§

impl<T, const N: usize> Simd<T, N>

source

pub const LEN: usize = N

🔬This is a nightly-only experimental API. (portable_simd)

Number of elements in this vector.

source

pub const fn len(&self) -> usize

🔬This is a nightly-only experimental API. (portable_simd)

Returns the number of elements in this SIMD vector.

§Examples
let v = u32x4::splat(0);
assert_eq!(v.len(), 4);
source

pub fn splat(value: T) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Constructs a new SIMD vector with all elements set to the given value.

§Examples
let v = u32x4::splat(8);
assert_eq!(v.as_array(), &[8, 8, 8, 8]);
source

pub const fn as_array(&self) -> &[T; N]

🔬This is a nightly-only experimental API. (portable_simd)

Returns an array reference containing the entire SIMD vector.

§Examples
let v: u64x4 = Simd::from_array([0, 1, 2, 3]);
assert_eq!(v.as_array(), &[0, 1, 2, 3]);
source

pub fn as_mut_array(&mut self) -> &mut [T; N]

🔬This is a nightly-only experimental API. (portable_simd)

Returns a mutable array reference containing the entire SIMD vector.

source

pub const fn from_array(array: [T; N]) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Converts an array to a SIMD vector.

source

pub const fn to_array(self) -> [T; N]

🔬This is a nightly-only experimental API. (portable_simd)

Converts a SIMD vector to an array.

source

pub const fn from_slice(slice: &[T]) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Converts a slice to a SIMD vector containing slice[..N].

§Panics

Panics if the slice’s length is less than the vector’s Simd::N. Use load_or_default for an alternative that does not panic.

§Example
let source = vec![1, 2, 3, 4, 5, 6];
let v = u32x4::from_slice(&source);
assert_eq!(v.as_array(), &[1, 2, 3, 4]);
source

pub fn copy_to_slice(self, slice: &mut [T])

🔬This is a nightly-only experimental API. (portable_simd)

Writes a SIMD vector to the first N elements of a slice.

§Panics

Panics if the slice’s length is less than the vector’s Simd::N.

§Example
let mut dest = vec![0; 6];
let v = u32x4::from_array([1, 2, 3, 4]);
v.copy_to_slice(&mut dest);
assert_eq!(&dest, &[1, 2, 3, 4, 0, 0]);
source

pub fn load_or_default(slice: &[T]) -> Simd<T, N>
where T: Default,

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements from slice. Elements are read so long as they’re in-bounds for the slice. Otherwise, the default value for the element type is returned.

§Examples
let vec: Vec<i32> = vec![10, 11];

let result = Simd::<i32, 4>::load_or_default(&vec);
assert_eq!(result, Simd::from_array([10, 11, 0, 0]));
source

pub fn load_or(slice: &[T], or: Simd<T, N>) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements from slice. Elements are read so long as they’re in-bounds for the slice. Otherwise, the corresponding value from or is passed through.

§Examples
let vec: Vec<i32> = vec![10, 11];
let or = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::load_or(&vec, or);
assert_eq!(result, Simd::from_array([10, 11, -3, -2]));
source

pub fn load_select_or_default( slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>, ) -> Simd<T, N>
where T: Default,

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled or out of bounds for the slice, that memory location is not accessed and the corresponding value from or is passed through.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let enable = Mask::from_array([true, true, false, true]);
let or = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::load_select(&vec, enable, or);
assert_eq!(result, Simd::from_array([10, 11, -3, 13]));
source

pub fn load_select( slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled or out of bounds for the slice, that memory location is not accessed and the corresponding value from or is passed through.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let enable = Mask::from_array([true, true, false, true]);
let or = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::load_select(&vec, enable, or);
assert_eq!(result, Simd::from_array([10, 11, -3, 13]));
source

pub unsafe fn load_select_unchecked( slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled, that memory location is not accessed and the corresponding value from or is passed through.

source

pub unsafe fn load_select_ptr( ptr: *const T, enable: Mask<<T as SimdElement>::Mask, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads contiguous elements starting at ptr. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled, that memory location is not accessed and the corresponding value from or is passed through.

source

pub fn gather_or( slice: &[T], idxs: Simd<usize, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads from potentially discontiguous indices in slice to construct a SIMD vector. If an index is out-of-bounds, the element is instead selected from the or vector.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);  // Note the index that is out-of-bounds
let alt = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::gather_or(&vec, idxs, alt);
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));
source

pub fn gather_or_default(slice: &[T], idxs: Simd<usize, N>) -> Simd<T, N>
where T: Default,

🔬This is a nightly-only experimental API. (portable_simd)

Reads from indices in slice to construct a SIMD vector. If an index is out-of-bounds, the element is set to the default given by T: Default.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);  // Note the index that is out-of-bounds

let result = Simd::gather_or_default(&vec, idxs);
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));
source

pub fn gather_select( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads from indices in slice to construct a SIMD vector. The mask enables all true indices and disables all false indices. If an index is disabled or is out-of-bounds, the element is selected from the or vector.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element

let result = Simd::gather_select(&vec, enable, idxs, alt);
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
source

pub unsafe fn gather_select_unchecked( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Reads from indices in slice to construct a SIMD vector. The mask enables all true indices and disables all false indices. If an index is disabled, the element is selected from the or vector.

§Safety

Calling this function with an enabled out-of-bounds index is undefined behavior even if the resulting value is not used.

§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
// If this mask was used to gather, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

// The out-of-bounds index has been masked, so it's safe to gather now.
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
source

pub unsafe fn gather_ptr(source: Simd<*const T, N>) -> Simd<T, N>
where T: Default,

🔬This is a nightly-only experimental API. (portable_simd)

Read elementwise from pointers into a SIMD vector.

§Safety

Each read must satisfy the same conditions as core::ptr::read.

§Example
let values = [6, 2, 4, 9];
let offsets = Simd::from_array([1, 0, 0, 3]);
let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
let gathered = unsafe { Simd::gather_ptr(source) };
assert_eq!(gathered, Simd::from_array([2, 6, 6, 9]));
source

pub unsafe fn gather_select_ptr( source: Simd<*const T, N>, enable: Mask<isize, N>, or: Simd<T, N>, ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)

Conditionally read elementwise from pointers into a SIMD vector. The mask enables all true pointers and disables all false pointers. If a pointer is disabled, the element is selected from the or vector, and no read is performed.

§Safety

Enabled elements must satisfy the same conditions as core::ptr::read.

§Example
let values = [6, 2, 4, 9];
let enable = Mask::from_array([true, true, false, true]);
let offsets = Simd::from_array([1, 0, 0, 3]);
let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
let gathered = unsafe { Simd::gather_select_ptr(source, enable, Simd::splat(0)) };
assert_eq!(gathered, Simd::from_array([2, 6, 0, 9]));
source

pub fn store_select( self, slice: &mut [T], enable: Mask<<T as SimdElement>::Mask, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Conditionally write contiguous elements to slice. The enable mask controls which elements are written, as long as they’re in-bounds of the slice. If the element is disabled or out of bounds, no memory access to that location is made.

§Examples
let mut arr = [0i32; 4];
let write = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([false, true, true, true]);

write.store_select(&mut arr[..3], enable);
assert_eq!(arr, [0, -4, -3, 0]);
source

pub unsafe fn store_select_unchecked( self, slice: &mut [T], enable: Mask<<T as SimdElement>::Mask, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Conditionally write contiguous elements to slice. The enable mask controls which elements are written.

§Safety

Every enabled element must be in bounds for the slice.

§Examples
let mut arr = [0i32; 4];
let write = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([false, true, true, true]);

unsafe { write.store_select_unchecked(&mut arr, enable) };
assert_eq!(arr, [0, -4, -3, -2]);
source

pub unsafe fn store_select_ptr( self, ptr: *mut T, enable: Mask<<T as SimdElement>::Mask, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Conditionally write contiguous elements starting from ptr. The enable mask controls which elements are written. When disabled, the memory location corresponding to that element is not accessed.

§Safety

Memory addresses for element are calculated pointer::wrapping_offset and each enabled element must satisfy the same conditions as core::ptr::write.

source

pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)

🔬This is a nightly-only experimental API. (portable_simd)

Writes the values in a SIMD vector to potentially discontiguous indices in slice. If an index is out-of-bounds, the write is suppressed without panicking. If two elements in the scattered vector would write to the same index only the last element is guaranteed to actually be written.

§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]); // Note the duplicate index.
let vals = Simd::from_array([-27, 82, -41, 124]);

vals.scatter(&mut vec, idxs); // two logical writes means the last wins.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);
source

pub fn scatter_select( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Writes values from a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true indices and disables all false indices. If an enabled index is out-of-bounds, the write is suppressed without panicking. If two enabled elements in the scattered vector would write to the same index, only the last element is guaranteed to actually be written.

§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]); // Includes an out-of-bounds index
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element

vals.scatter_select(&mut vec, enable, idxs); // The last write is masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
source

pub unsafe fn scatter_select_unchecked( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Writes values from a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true indices and disables all false indices. If two enabled elements in the scattered vector would write to the same index, only the last element is guaranteed to actually be written.

§Safety

Calling this function with an enabled out-of-bounds index is undefined behavior, and may lead to memory corruption.

§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Masks the final index
// If this mask was used to scatter, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

// We have masked the OOB index, so it's safe to scatter now.
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// The second write to index 0 was masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
source

pub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)

🔬This is a nightly-only experimental API. (portable_simd)

Write pointers elementwise into a SIMD vector.

§Safety

Each write must satisfy the same conditions as core::ptr::write.

§Example
let mut values = [0; 4];
let offset = Simd::from_array([3, 2, 1, 0]);
let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
unsafe { Simd::from_array([6, 3, 5, 7]).scatter_ptr(ptrs); }
assert_eq!(values, [7, 5, 3, 6]);
source

pub unsafe fn scatter_select_ptr( self, dest: Simd<*mut T, N>, enable: Mask<isize, N>, )

🔬This is a nightly-only experimental API. (portable_simd)

Conditionally write pointers elementwise into a SIMD vector. The mask enables all true pointers and disables all false pointers. If a pointer is disabled, the write to its pointee is skipped.

§Safety

Enabled pointers must satisfy the same conditions as core::ptr::write.

§Example
let mut values = [0; 4];
let offset = Simd::from_array([3, 2, 1, 0]);
let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
let enable = Mask::from_array([true, true, false, false]);
unsafe { Simd::from_array([6, 3, 5, 7]).scatter_select_ptr(ptrs, enable); }
assert_eq!(values, [0, 0, 3, 6]);

Trait Implementations

source§

impl<T, const N: usize> Add<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Add<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the + operator.
source§

fn add(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Add<&Simd<T, N>>>::Output

Performs the + operation. Read more
source§

impl<const N: usize> Add for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the + operator.
source§

fn add(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Add>::Output

Performs the + operation. Read more
source§

impl<T, U, const N: usize> AddAssign<U> for Simd<T, N>
where Simd<T, N>: Add<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn add_assign(&mut self, rhs: U)

Performs the += operation. Read more
source§

impl<T, const N: usize> AsMut<[T]> for Simd<T, N>

source§

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>

source§

fn as_mut(&mut self) -> &mut [T; N]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl<T, const N: usize> AsRef<[T]> for Simd<T, N>

source§

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>

source§

fn as_ref(&self) -> &[T; N]

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl<T, const N: usize> BitAnd<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: BitAnd<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the & operator.
source§

fn bitand(self, rhs: &Simd<T, N>) -> <Simd<T, N> as BitAnd<&Simd<T, N>>>::Output

Performs the & operation. Read more
source§

impl<T, U, const N: usize> BitAndAssign<U> for Simd<T, N>
where Simd<T, N>: BitAnd<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn bitand_assign(&mut self, rhs: U)

Performs the &= operation. Read more
source§

impl<T, const N: usize> BitOr<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: BitOr<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the | operator.
source§

fn bitor(self, rhs: &Simd<T, N>) -> <Simd<T, N> as BitOr<&Simd<T, N>>>::Output

Performs the | operation. Read more
source§

impl<T, U, const N: usize> BitOrAssign<U> for Simd<T, N>
where Simd<T, N>: BitOr<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn bitor_assign(&mut self, rhs: U)

Performs the |= operation. Read more
source§

impl<T, const N: usize> BitXor<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: BitXor<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the ^ operator.
source§

fn bitxor(self, rhs: &Simd<T, N>) -> <Simd<T, N> as BitXor<&Simd<T, N>>>::Output

Performs the ^ operation. Read more
source§

impl<T, U, const N: usize> BitXorAssign<U> for Simd<T, N>
where Simd<T, N>: BitXor<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn bitxor_assign(&mut self, rhs: U)

Performs the ^= operation. Read more
source§

impl<T, const N: usize> Clone for Simd<T, N>

source§

fn clone(&self) -> Simd<T, N>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<T, const N: usize> Debug for Simd<T, N>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

A Simd<T, N> has a debug format like the one for [T]:

let floats = Simd::<f32, 4>::splat(-1.0);
assert_eq!(format!("{:?}", [-1.0; 4]), format!("{:?}", floats));
source§

impl<T, const N: usize> Default for Simd<T, N>

source§

fn default() -> Simd<T, N>

Returns the “default value” for a type. Read more
source§

impl<T, const N: usize> Div<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Div<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the / operator.
source§

fn div(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Div<&Simd<T, N>>>::Output

Performs the / operation. Read more
source§

impl<const N: usize> Div for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the / operator.
source§

fn div(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Div>::Output

Performs the / operation. Read more
source§

impl<T, U, const N: usize> DivAssign<U> for Simd<T, N>
where Simd<T, N>: Div<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn div_assign(&mut self, rhs: U)

Performs the /= operation. Read more
source§

impl<T, const N: usize> From<[T; N]> for Simd<T, N>

source§

fn from(array: [T; N]) -> Simd<T, N>

Converts to this type from the input type.
source§

impl<T, const N: usize> From<Mask<T, N>> for Simd<T, N>

source§

fn from(value: Mask<T, N>) -> Simd<T, N>

Converts to this type from the input type.
source§

impl<T, const N: usize> Hash for Simd<T, N>

source§

fn hash<H>(&self, state: &mut H)
where H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl<I, T, const N: usize> Index<I> for Simd<T, N>

§

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<Simd<T, N> as Index<I>>::Output

Performs the indexing (container[index]) operation. Read more
source§

impl<I, T, const N: usize> IndexMut<I> for Simd<T, N>

source§

fn index_mut(&mut self, index: I) -> &mut <Simd<T, N> as Index<I>>::Output

Performs the mutable indexing (container[index]) operation. Read more
source§

impl<T, const N: usize> Mul<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Mul<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the * operator.
source§

fn mul(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Mul<&Simd<T, N>>>::Output

Performs the * operation. Read more
source§

impl<const N: usize> Mul for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the * operator.
source§

fn mul(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Mul>::Output

Performs the * operation. Read more
source§

impl<T, U, const N: usize> MulAssign<U> for Simd<T, N>
where Simd<T, N>: Mul<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn mul_assign(&mut self, rhs: U)

Performs the *= operation. Read more
source§

impl<const N: usize> Neg for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the - operator.
source§

fn neg(self) -> <Simd<f64, N> as Neg>::Output

Performs the unary - operation. Read more
source§

impl<T, const N: usize> Ord for Simd<T, N>

source§

fn cmp(&self, other: &Simd<T, N>) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<T, const N: usize> PartialEq for Simd<T, N>

source§

fn eq(&self, other: &Simd<T, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.
source§

fn ne(&self, other: &Simd<T, N>) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<T, const N: usize> PartialOrd for Simd<T, N>

source§

fn partial_cmp(&self, other: &Simd<T, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<'a, const N: usize> Product<&'a Simd<f64, N>> for Simd<f64, N>

source§

fn product<I>(iter: I) -> Simd<f64, N>
where I: Iterator<Item = &'a Simd<f64, N>>,

Method which takes an iterator and generates Self from the elements by multiplying the items.
source§

impl<const N: usize> Product for Simd<f64, N>

source§

fn product<I>(iter: I) -> Simd<f64, N>
where I: Iterator<Item = Simd<f64, N>>,

Method which takes an iterator and generates Self from the elements by multiplying the items.
source§

impl<T, const N: usize> Rem<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Rem<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the % operator.
source§

fn rem(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Rem<&Simd<T, N>>>::Output

Performs the % operation. Read more
source§

impl<const N: usize> Rem for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the % operator.
source§

fn rem(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Rem>::Output

Performs the % operation. Read more
source§

impl<T, U, const N: usize> RemAssign<U> for Simd<T, N>
where Simd<T, N>: Rem<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn rem_assign(&mut self, rhs: U)

Performs the %= operation. Read more
source§

impl<T, const N: usize> Shl<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Shl<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the << operator.
source§

fn shl(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Shl<&Simd<T, N>>>::Output

Performs the << operation. Read more
source§

impl<T, U, const N: usize> ShlAssign<U> for Simd<T, N>
where Simd<T, N>: Shl<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn shl_assign(&mut self, rhs: U)

Performs the <<= operation. Read more
source§

impl<T, const N: usize> Shr<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Shr<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the >> operator.
source§

fn shr(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Shr<&Simd<T, N>>>::Output

Performs the >> operation. Read more
source§

impl<T, U, const N: usize> ShrAssign<U> for Simd<T, N>
where Simd<T, N>: Shr<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn shr_assign(&mut self, rhs: U)

Performs the >>= operation. Read more
source§

impl<const N: usize> SimdFloat for Simd<f64, N>

§

type Mask = Mask<<i64 as SimdElement>::Mask, N>

🔬This is a nightly-only experimental API. (portable_simd)
Mask type used for manipulating this SIMD vector type.
§

type Scalar = f64

🔬This is a nightly-only experimental API. (portable_simd)
Scalar type contained by this SIMD vector type.
§

type Bits = Simd<u64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Bit representation of this SIMD vector type.
§

type Cast<T: SimdElement> = Simd<T, N>

🔬This is a nightly-only experimental API. (portable_simd)
A SIMD vector with a different element type.
source§

fn cast<T>(self) -> <Simd<f64, N> as SimdFloat>::Cast<T>
where T: SimdCast,

🔬This is a nightly-only experimental API. (portable_simd)
Performs elementwise conversion of this vector’s elements to another SIMD-valid type. Read more
source§

unsafe fn to_int_unchecked<I>(self) -> <Simd<f64, N> as SimdFloat>::Cast<I>
where I: SimdCast, <Simd<f64, N> as SimdFloat>::Scalar: FloatToInt<I>,

🔬This is a nightly-only experimental API. (portable_simd)
Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type. Read more
source§

fn to_bits(self) -> Simd<u64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Raw transmutation to an unsigned integer vector type with the same size and number of elements.
source§

fn from_bits(bits: Simd<u64, N>) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Raw transmutation from an unsigned integer vector type with the same size and number of elements.
source§

fn abs(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the absolute value of the equivalently-indexed element in self.
source§

fn recip(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Takes the reciprocal (inverse) of each element, 1/x.
source§

fn to_degrees(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Converts each element from radians to degrees.
source§

fn to_radians(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Converts each element from degrees to radians.
source§

fn is_sign_positive(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.
source§

fn is_sign_negative(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.
source§

fn is_nan(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if its value is NaN.
source§

fn is_infinite(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if its value is positive infinity or negative infinity.
source§

fn is_finite(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if its value is neither infinite nor NaN.
source§

fn is_subnormal(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if its value is subnormal.
source§

fn is_normal(self) -> <Simd<f64, N> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each element if its value is neither zero, infinite, subnormal, nor NaN.
source§

fn signum(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Replaces each element with a number that represents its sign. Read more
source§

fn copysign(self, sign: Simd<f64, N>) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Returns each element with the magnitude of self and the sign of sign. Read more
source§

fn simd_min(self, other: Simd<f64, N>) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Returns the minimum of each element. Read more
source§

fn simd_max(self, other: Simd<f64, N>) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Returns the maximum of each element. Read more
source§

fn simd_clamp(self, min: Simd<f64, N>, max: Simd<f64, N>) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Restrict each element to a certain interval unless it is NaN. Read more
source§

fn reduce_sum(self) -> <Simd<f64, N> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the elements of the vector. Read more
source§

fn reduce_product(self) -> <Simd<f64, N> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Reducing multiply. Returns the product of the elements of the vector. Read more
source§

fn reduce_max(self) -> <Simd<f64, N> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the maximum element in the vector. Read more
source§

fn reduce_min(self) -> <Simd<f64, N> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the minimum element in the vector. Read more
source§

impl<const N: usize> SimdPartialEq for Simd<f64, N>

§

type Mask = Mask<<f64 as SimdElement>::Mask, N>

🔬This is a nightly-only experimental API. (portable_simd)
The mask type returned by each comparison.
source§

fn simd_eq(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is equal to the corresponding element in other.
source§

fn simd_ne(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is equal to the corresponding element in other.
source§

impl<const N: usize> SimdPartialOrd for Simd<f64, N>

source§

fn simd_lt(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is less than the corresponding element in other.
source§

fn simd_le(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is less than or equal to the corresponding element in other.
source§

fn simd_gt(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is greater than the corresponding element in other.
source§

fn simd_ge(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Test if each element is greater than or equal to the corresponding element in other.
source§

impl<const N: usize> StdFloat for Simd<f64, N>

source§

fn fract(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Returns the floating point’s fractional value, with its integer part removed.
source§

fn sin(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the sine of the value in the equivalently-indexed element in self.
source§

fn cos(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the cosine of the value in the equivalently-indexed element in self.
source§

fn exp(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the exponential (base e) of the value in the equivalently-indexed element in self.
source§

fn exp2(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the exponential (base 2) of the value in the equivalently-indexed element in self.
source§

fn ln(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the natural logarithm of the value in the equivalently-indexed element in self.
source§

fn log2(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the base-2 logarithm of the value in the equivalently-indexed element in self.
source§

fn log10(self) -> Simd<f64, N>

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the base-10 logarithm of the value in the equivalently-indexed element in self.
source§

fn mul_add(self, a: Self, b: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Elementwise fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add. Read more
source§

fn sqrt(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the square root value of the equivalently-indexed element in self
source§

fn log(self, base: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Produces a vector where every element has the logarithm with respect to an arbitrary in the equivalently-indexed elements in self and base.
source§

fn ceil(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Returns the smallest integer greater than or equal to each element.
source§

fn floor(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Returns the largest integer value less than or equal to each element.
source§

fn round(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Rounds to the nearest integer value. Ties round toward zero.
source§

fn trunc(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
Returns the floating point’s integer value, with its fractional part removed.
source§

impl<T, const N: usize> Sub<&Simd<T, N>> for Simd<T, N>
where T: SimdElement, Simd<T, N>: Sub<Output = Simd<T, N>>, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<T, N>

The resulting type after applying the - operator.
source§

fn sub(self, rhs: &Simd<T, N>) -> <Simd<T, N> as Sub<&Simd<T, N>>>::Output

Performs the - operation. Read more
source§

impl<const N: usize> Sub for Simd<f64, N>

§

type Output = Simd<f64, N>

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Sub>::Output

Performs the - operation. Read more
source§

impl<T, U, const N: usize> SubAssign<U> for Simd<T, N>
where Simd<T, N>: Sub<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,

source§

fn sub_assign(&mut self, rhs: U)

Performs the -= operation. Read more
source§

impl<'a, const N: usize> Sum<&'a Simd<f64, N>> for Simd<f64, N>

source§

fn sum<I>(iter: I) -> Simd<f64, N>
where I: Iterator<Item = &'a Simd<f64, N>>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.
source§

impl<const N: usize> Sum for Simd<f64, N>

source§

fn sum<I>(iter: I) -> Simd<f64, N>
where I: Iterator<Item = Simd<f64, N>>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.
source§

impl<T, const N: usize> TryFrom<&[T]> for Simd<T, N>

§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[T]) -> Result<Simd<T, N>, TryFromSliceError>

Performs the conversion.
source§

impl<T, const N: usize> TryFrom<&mut [T]> for Simd<T, N>

§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &mut [T]) -> Result<Simd<T, N>, TryFromSliceError>

Performs the conversion.
source§

impl<T, const N: usize> Copy for Simd<T, N>

source§

impl<T, const N: usize> Eq for Simd<T, N>