# Type Alias std::simd::prelude::f64x16

source ·

    pub type f64x16 = Simd<f64, 16>;

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Expand description

A SIMD vector with 16 elements of type `f64`.

## Aliased Type§

    struct f64x16(/* private fields */);

## Implementations§

source§

### impl<T, const LANES: usize> Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source

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

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

Reverse the order of the lanes in the vector.

source

#### pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>

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

Rotates the vector such that the first `OFFSET` elements of the slice move to the end while the last `LANES - OFFSET` elements move to the front. After calling `rotate_lanes_left`, the element previously in lane `OFFSET` will become the first element in the slice.

source

#### pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>

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

Rotates the vector such that the first `LANES - OFFSET` elements of the vector move to the end while the last `OFFSET` elements move to the front. After calling `rotate_lanes_right`, the element previously at index `LANES - OFFSET` will become the first element in the slice.

source

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

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

Interleave two vectors.

The resulting vectors contain lanes 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]);

Run
source

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

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

Deinterleave two vectors.

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

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

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]);

Run
source§

### impl<T, const N: usize> Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source

#### pub const LANES: usize = N

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

Number of elements in this vector.

source

#### pub const fn lanes(&self) -> usize

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

Returns the number of elements in this SIMD vector.

##### Examples

    let v = u32x4::splat(0);
    assert_eq!(v.lanes(), 4);

Run
source

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

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

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]);

Run
source

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

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

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]);

Run
source

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

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

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` #86656)

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` #86656)

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` #86656)

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

##### 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]);

Run
source

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

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

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]);

Run
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` #86656)

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]));

Run
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` #86656)

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]));

Run
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` #86656)

Reads from indices in `slice` to construct a SIMD vector. The mask `enable`s 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]));

Run
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` #86656)

Reads from indices in `slice` to construct a SIMD vector. The mask `enable`s 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 `enable`d 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]));

Run
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` #86656)

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]));

Run
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` #86656)

Conditionally read elementwise from pointers into a SIMD vector. The mask `enable`s 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]));

Run
source

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

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

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]);

Run
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` #86656)

Writes values from a SIMD vector to multiple potentially discontiguous indices in `slice`. The mask `enable`s 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]);

Run
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` #86656)

Writes values from a SIMD vector to multiple potentially discontiguous indices in `slice`. The mask `enable`s 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]);

Run
source

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

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

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]);

Run
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` #86656)

Conditionally write pointers elementwise into a SIMD vector. The mask `enable`s 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]);

Run

## Trait Implementations§

source§

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `+` operator.
source§

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

Performs the `+` operation. Read more
source§

### impl<const N: usize> Add<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### 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<Simd<f64, N>>>::Output

Performs the `+` operation. Read more
source§

### impl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Add<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: 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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

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

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

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `&` operator.
source§

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

Performs the `&` operation. Read more
source§

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

source§

#### fn bitand_assign(&mut self, rhs: U)

Performs the `&=` operation. Read more
source§

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `|` operator.
source§

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

Performs the `|` operation. Read more
source§

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

source§

#### fn bitor_assign(&mut self, rhs: U)

Performs the `|=` operation. Read more
source§

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `^` operator.
source§

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

Performs the `^` operation. Read more
source§

### impl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES>where Simd<T, LANES>: BitXor<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: 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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

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 LANES: usize> Debug for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Debug,

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));

Run
source§

### impl<T, const N: usize> Default for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Default,

source§

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

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

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `/` operator.
source§

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

Performs the `/` operation. Read more
source§

### impl<const N: usize> Div<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### 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<Simd<f64, N>>>::Output

Performs the `/` operation. Read more
source§

### impl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Div<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: 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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

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

Converts to this type from the input type.
source§

### impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

source§

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

Converts to this type from the input type.
source§

### impl<T, const N: usize> Hash for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Hash,

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 LANES: usize> Index<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

§

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

The returned type after indexing.
source§

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

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

### impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

source§

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

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

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `*` operator.
source§

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

Performs the `*` operation. Read more
source§

### impl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### 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<Simd<f64, N>>>::Output

Performs the `*` operation. Read more
source§

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

source§

#### fn mul_assign(&mut self, rhs: U)

Performs the `*=` operation. Read more
source§

### impl<const LANES: usize> Neg for Simd<f64, LANES>where f64: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<f64, LANES>

The resulting type after applying the `-` operator.
source§

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

Performs the unary `-` operation. Read more
source§

### impl<T, const N: usize> Ord for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Ord,

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) -> Selfwhere Self: Sized,

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

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

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

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

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

### impl<T, const N: usize> PartialEq<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialEq<T>,

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<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialOrd<T>,

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 LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

### impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `%` operator.
source§

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

Performs the `%` operation. Read more
source§

### impl<const N: usize> Rem<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### 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<Simd<f64, N>>>::Output

Performs the `%` operation. Read more
source§

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

source§

#### fn rem_assign(&mut self, rhs: U)

Performs the `%=` operation. Read more
source§

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

§

#### type Output = Simd<T, LANES>

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

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

Performs the `<<` operation. Read more
source§

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

source§

#### fn shl_assign(&mut self, rhs: U)

Performs the `<<=` operation. Read more
source§

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

§

#### type Output = Simd<T, LANES>

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

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

Performs the `>>` operation. Read more
source§

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

source§

#### fn shr_assign(&mut self, rhs: U)

Performs the `>>=` operation. Read more
source§

### impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

#### type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

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

#### type Scalar = f64

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

#### type Bits = Simd<u64, LANES>

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

#### type Cast<T: SimdElement> = Simd<T, LANES>

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

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

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
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, LANES> as SimdFloat>::Cast<I>where I: SimdCast, <Simd<f64, LANES> as SimdFloat>::Scalar: FloatToInt<I>,

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
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, LANES>

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

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

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

#### fn abs(self) -> Simd<f64, LANES>

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

#### fn recip(self) -> Simd<f64, LANES>

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

#### fn to_degrees(self) -> Simd<f64, LANES>

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

#### fn to_radians(self) -> Simd<f64, LANES>

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

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

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

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

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns true for each lane if it has a negative sign, including `-0.0`, `NaN`s with negative sign bit and negative infinity.
source§

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

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

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

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

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

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

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

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

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

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

#### fn signum(self) -> Simd<f64, LANES>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

#### type Mask = Mask<<f64 as SimdElement>::Mask, LANES>

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

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

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

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

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

### impl<const LANES: usize> SimdPartialOrd for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

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

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

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

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

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

### impl<const N: usize> StdFloat for Simd<f64, N>where LaneCount<N>: SupportedLaneCount,

source§

#### fn fract(self) -> Self

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

Returns the floating point’s fractional value, with its integer part removed.

source§

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

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
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` #86656)
Produces a vector where every lane has the square root value of the equivalently-indexed lane in `self`
source§

#### fn ceil(self) -> Self

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

#### fn floor(self) -> Self

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

#### fn round(self) -> Self

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

#### fn trunc(self) -> Self

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

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

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `-` operator.
source§

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

Performs the `-` operation. Read more
source§

### impl<const N: usize> Sub<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### 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<Simd<f64, N>>>::Output

Performs the `-` operation. Read more
source§

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

source§

#### fn sub_assign(&mut self, rhs: U)

Performs the `-=` operation. Read more
source§

### impl<'a, const LANES: usize> Sum<&'a Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

### impl<const LANES: usize> Sum<Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

§

#### 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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

§

#### 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>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

### impl<T, const N: usize> Eq for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Eq,