pub struct Simd<T, const LANES: usize>(_)
where
         T: SimdElement,
         LaneCount<LANES>: SupportedLaneCount;
🔬This is a nightly-only experimental API. (portable_simd)
Available on non-crate feature miri-test-libstd only.
Expand description

A SIMD vector of LANES elements of type T. Simd<T, N> has the same shape as [T; N], but operates like T.

Two vectors of the same type and length will, by convention, support the operators (+, *, etc.) that T does. These take the lanes at each index on the left-hand side and right-hand side, perform the operation, and return the result in the same lane in a vector of equal size. For a given operator, this is equivalent to zipping the two arrays together and mapping the operator over each lane.

let a0: [i32; 4] = [-2, 0, 2, 4];
let a1 = [10, 9, 8, 7];
let zm_add = a0.zip(a1).map(|(lhs, rhs)| lhs + rhs);
let zm_mul = a0.zip(a1).map(|(lhs, rhs)| lhs * rhs);

// `Simd<T, N>` implements `From<[T; N]>`
let (v0, v1) = (Simd::from(a0), Simd::from(a1));
// Which means arrays implement `Into<Simd<T, N>>`.
assert_eq!(v0 + v1, zm_add.into());
assert_eq!(v0 * v1, zm_mul.into());

Simd with integers has the quirk that these operations are also inherently wrapping, as if T was Wrapping<T>. Thus, Simd does not implement wrapping_add, because that is the default behavior. This means there is no warning on overflows, even in “debug” builds. For most applications where Simd is appropriate, it is “not a bug” to wrap, and even “debug builds” are unlikely to tolerate the loss of performance. You may want to consider using explicitly checked arithmetic if such is required. Division by zero still causes a panic, so you may want to consider using floating point numbers if that is unacceptable.

Layout

Simd<T, N> has a layout similar to [T; N] (identical “shapes”), but with a greater alignment. [T; N] is aligned to T, but Simd<T, N> will have an alignment based on both T and N. It is thus sound to transmute Simd<T, N> to [T; N], and will typically optimize to zero cost, but the reverse transmutation is more likely to require a copy the compiler cannot simply elide.

ABI “Features”

Due to Rust’s safety guarantees, Simd<T, N> is currently passed to and from functions via memory, not SIMD registers, except as an optimization. #[inline] hints are recommended on functions that accept Simd<T, N> or return it. The need for this may be corrected in the future.

Safe SIMD with Unsafe Rust

Operations with Simd are typically safe, but there are many reasons to want to combine SIMD with unsafe code. Care must be taken to respect differences between Simd and other types it may be transformed into or derived from. In particular, the layout of Simd<T, N> may be similar to [T; N], and may allow some transmutations, but references to [T; N] are not interchangeable with those to Simd<T, N>. Thus, when using unsafe Rust to read and write Simd<T, N> through raw pointers, it is a good idea to first try with read_unaligned and write_unaligned. This is because:

  • read and write require full alignment (in this case, Simd<T, N>’s alignment)
  • the likely source for reading or destination for writing Simd<T, N> is [T] and similar types, aligned to T
  • combining these actions would violate the unsafe contract and explode the program into a puff of undefined behavior
  • the compiler can implicitly adjust layouts to make unaligned reads or writes fully aligned if it sees the optimization
  • most contemporary processors suffer no performance penalty for “unaligned” reads and writes that are aligned at runtime

By imposing less obligations, unaligned functions are less likely to make the program unsound, and may be just as fast as stricter alternatives. When trying to guarantee alignment, [T]::as_simd is an option for converting [T] to [Simd<T, N>], and allows soundly operating on an aligned SIMD body, but it may cost more time when handling the scalar head and tail. If these are not sufficient, then it is most ideal to design data structures to be already aligned to the Simd<T, N> you wish to use before using unsafe Rust to read or write. More conventional ways to compensate for these facts, like materializing Simd to or from an array first, are handled by safe methods like Simd::from_array and Simd::from_slice.

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)

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)

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)

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)

Interleave two vectors.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

#![feature(portable_simd)]
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, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)

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

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.

#![feature(portable_simd)]
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§

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

source

pub const LANES: usize = LANES

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

Number of lanes in this vector.

source

pub const fn lanes(&self) -> usize

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

Returns the number of lanes in this SIMD vector.

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

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

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

Constructs a new SIMD vector with all lanes 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; LANES]

🔬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; LANES]

🔬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; LANES]) -> Simd<T, LANES>

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

Converts an array to a SIMD vector.

source

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

🔬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, LANES>

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

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

Panics

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

Examples
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 cast<U>(self) -> Simd<U, LANES>where U: SimdElement,

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

Performs lanewise conversion of a SIMD vector’s elements to another SIMD-valid type.

This follows the semantics of Rust’s as conversion for casting integers to unsigned integers (interpreting as the other type, so -1 to MAX), and from floats to integers (truncating, or saturating at the limits) for each lane, or vice versa.

Examples
let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);
let ints = floats.cast::<i32>();
assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));

// Formally equivalent, but `Simd::cast` can optimize better.
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));

// The float conversion does not round-trip.
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));
source

pub unsafe fn to_int_unchecked<I>(self) -> Simd<I, LANES>where T: FloatToInt<I>, I: SimdElement,

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

Safety

The value must:

  • Not be NaN
  • Not be infinite
  • Be representable in the return type, after truncating off its fractional part

If these requirements are infeasible or costly, consider using the safe function cast, which saturates on conversion.

source

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

🔬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 lane 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::gather_or(&vec, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));
source

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

🔬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 lane is set to the default value for the type.

Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);

let result = Simd::gather_or_default(&vec, idxs); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));
source

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

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

Reads from potentially discontiguous indices in slice to construct a SIMD vector. The mask enables all true lanes and disables all false lanes. If an index is disabled or is out-of-bounds, the lane 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

let result = Simd::gather_select(&vec, enable, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
source

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

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

Reads from potentially discontiguous indices in slice to construct a SIMD vector. The mask enables all true lanes and disables all false lanes. If an index is disabled, the lane 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the final mask lane.
// 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()));

// We have masked the OOB lane, 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 fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)

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

Writes the values in a SIMD vector to potentially discontiguous indices in slice. If two lanes in the scattered vector would write to the same index only the last lane 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]);
let vals = Simd::from_array([-27, 82, -41, 124]);

vals.scatter(&mut vec, idxs); // index 0 receives two writes.
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, LANES>, idxs: Simd<usize, LANES> )

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

Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true lanes and disables all false lanes. If an enabled index is out-of-bounds, the lane is not written. If two enabled lanes in the scattered vector would write to the same index, only the last lane 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]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

vals.scatter_select(&mut vec, enable, idxs); // index 0's second 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, LANES>, idxs: Simd<usize, LANES> )

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

Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true lanes and disables all false lanes. If two enabled lanes in the scattered vector would write to the same index, only the last lane 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]); // Note the mask of the last lane.
// 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 lane, so it's safe to scatter now.
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// index 0's second write is masked, thus was omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

Trait Implementations§

source§

impl<'lhs, 'rhs, T, const LANES: usize> Add<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Add<&'rhs Simd<T, LANES>>>::Output

Performs the + operation. Read more
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<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<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<f32, N>

The resulting type after applying the + operator.
source§

fn add(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Add<Simd<f32, N>>>::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<const N: usize> Add<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<i32, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<i64, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<i8, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<isize, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<u16, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<u32, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<u64, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<u8, N>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

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

§

type Output = Simd<usize, N>

The resulting type after applying the + operator.
source§

fn add( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Add<Simd<usize, 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 LANES: usize> AsMut<[T]> for Simd<T, LANES>where LaneCount<LANES>: 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 LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement,

source§

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

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

impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES>where LaneCount<LANES>: 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 LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement,

source§

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

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

impl<T, const LANES: usize> Binary for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Binary,

source§

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

Formats the value using the given formatter.
source§

impl<'lhs, 'rhs, T, const LANES: usize> BitAnd<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as BitAnd<&'rhs Simd<T, LANES>>>::Output

Performs the & operation. Read more
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, 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<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i32, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i64, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i8, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<isize, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u16, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

The resulting type after applying the & operator.
source§

fn bitand( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as BitAnd<Simd<usize, N>>>::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<'lhs, 'rhs, T, const LANES: usize> BitOr<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as BitOr<&'rhs Simd<T, LANES>>>::Output

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, 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<const N: usize> BitOr<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i32, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i64, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i8, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<isize, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u16, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<const N: usize> BitOr<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

The resulting type after applying the | operator.
source§

fn bitor( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as BitOr<Simd<usize, N>>>::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<'lhs, 'rhs, T, const LANES: usize> BitXor<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as BitXor<&'rhs Simd<T, LANES>>>::Output

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, 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<const N: usize> BitXor<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i32, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i64, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i8, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<isize, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u16, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<const N: usize> BitXor<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

The resulting type after applying the ^ operator.
source§

fn bitxor( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as BitXor<Simd<usize, N>>>::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 LANES: usize> Clone for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

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

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>

Formats the value using the given formatter. Read more
source§

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

source§

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

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

impl<'lhs, 'rhs, T, const LANES: usize> Div<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Div<&'rhs Simd<T, LANES>>>::Output

Performs the / operation. 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<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<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<f32, N>

The resulting type after applying the / operator.
source§

fn div(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Div<Simd<f32, N>>>::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<const N: usize> Div<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<i32, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<i64, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<i8, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<isize, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<u16, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<u32, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<u64, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<u8, N>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

§

type Output = Simd<usize, N>

The resulting type after applying the / operator.
source§

fn div( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Div<Simd<usize, 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 LANES: usize> From<[T; LANES]> for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement,

source§

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

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

source§

fn from(vector: Simd<T, LANES>) -> [T; LANES]

Converts to this type from the input type.
source§

impl From<Simd<f32, 16>> for __m512

source§

fn from(value: Simd<f32, 16>) -> __m512

Converts to this type from the input type.
source§

impl From<Simd<f32, 4>> for __m128

source§

fn from(value: Simd<f32, 4>) -> __m128

Converts to this type from the input type.
source§

impl From<Simd<f32, 8>> for __m256

source§

fn from(value: Simd<f32, 8>) -> __m256

Converts to this type from the input type.
source§

impl From<Simd<f64, 2>> for __m128d

source§

fn from(value: Simd<f64, 2>) -> __m128d

Converts to this type from the input type.
source§

impl From<Simd<f64, 4>> for __m256d

source§

fn from(value: Simd<f64, 4>) -> __m256d

Converts to this type from the input type.
source§

impl From<Simd<f64, 8>> for __m512d

source§

fn from(value: Simd<f64, 8>) -> __m512d

Converts to this type from the input type.
source§

impl From<Simd<i16, 16>> for __m256i

source§

fn from(value: Simd<i16, 16>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<i16, 32>> for __m512i

source§

fn from(value: Simd<i16, 32>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<i16, 8>> for __m128i

source§

fn from(value: Simd<i16, 8>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<i32, 16>> for __m512i

source§

fn from(value: Simd<i32, 16>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<i32, 4>> for __m128i

source§

fn from(value: Simd<i32, 4>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<i32, 8>> for __m256i

source§

fn from(value: Simd<i32, 8>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<i64, 2>> for __m128i

source§

fn from(value: Simd<i64, 2>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<i64, 4>> for __m256i

source§

fn from(value: Simd<i64, 4>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<i64, 8>> for __m512i

source§

fn from(value: Simd<i64, 8>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<i8, 16>> for __m128i

source§

fn from(value: Simd<i8, 16>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<i8, 32>> for __m256i

source§

fn from(value: Simd<i8, 32>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<i8, 64>> for __m512i

source§

fn from(value: Simd<i8, 64>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<isize, 2>> for __m128i

source§

fn from(value: Simd<isize, 2>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<isize, 4>> for __m256i

source§

fn from(value: Simd<isize, 4>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<isize, 8>> for __m512i

source§

fn from(value: Simd<isize, 8>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<u16, 16>> for __m256i

source§

fn from(value: Simd<u16, 16>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<u16, 32>> for __m512i

source§

fn from(value: Simd<u16, 32>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<u16, 8>> for __m128i

source§

fn from(value: Simd<u16, 8>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<u32, 16>> for __m512i

source§

fn from(value: Simd<u32, 16>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<u32, 4>> for __m128i

source§

fn from(value: Simd<u32, 4>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<u32, 8>> for __m256i

source§

fn from(value: Simd<u32, 8>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<u64, 2>> for __m128i

source§

fn from(value: Simd<u64, 2>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<u64, 4>> for __m256i

source§

fn from(value: Simd<u64, 4>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<u64, 8>> for __m512i

source§

fn from(value: Simd<u64, 8>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<u8, 16>> for __m128i

source§

fn from(value: Simd<u8, 16>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<u8, 32>> for __m256i

source§

fn from(value: Simd<u8, 32>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<u8, 64>> for __m512i

source§

fn from(value: Simd<u8, 64>) -> __m512i

Converts to this type from the input type.
source§

impl From<Simd<usize, 2>> for __m128i

source§

fn from(value: Simd<usize, 2>) -> __m128i

Converts to this type from the input type.
source§

impl From<Simd<usize, 4>> for __m256i

source§

fn from(value: Simd<usize, 4>) -> __m256i

Converts to this type from the input type.
source§

impl From<Simd<usize, 8>> for __m512i

source§

fn from(value: Simd<usize, 8>) -> __m512i

Converts to this type from the input type.
source§

impl From<__m128> for Simd<f32, 4>

source§

fn from(value: __m128) -> Simd<f32, 4>

Converts to this type from the input type.
source§

impl From<__m128d> for Simd<f64, 2>

source§

fn from(value: __m128d) -> Simd<f64, 2>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<i16, 8>

source§

fn from(value: __m128i) -> Simd<i16, 8>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<i32, 4>

source§

fn from(value: __m128i) -> Simd<i32, 4>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<i64, 2>

source§

fn from(value: __m128i) -> Simd<i64, 2>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<i8, 16>

source§

fn from(value: __m128i) -> Simd<i8, 16>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<isize, 2>

source§

fn from(value: __m128i) -> Simd<isize, 2>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<u16, 8>

source§

fn from(value: __m128i) -> Simd<u16, 8>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<u32, 4>

source§

fn from(value: __m128i) -> Simd<u32, 4>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<u64, 2>

source§

fn from(value: __m128i) -> Simd<u64, 2>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<u8, 16>

source§

fn from(value: __m128i) -> Simd<u8, 16>

Converts to this type from the input type.
source§

impl From<__m128i> for Simd<usize, 2>

source§

fn from(value: __m128i) -> Simd<usize, 2>

Converts to this type from the input type.
source§

impl From<__m256> for Simd<f32, 8>

source§

fn from(value: __m256) -> Simd<f32, 8>

Converts to this type from the input type.
source§

impl From<__m256d> for Simd<f64, 4>

source§

fn from(value: __m256d) -> Simd<f64, 4>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<i16, 16>

source§

fn from(value: __m256i) -> Simd<i16, 16>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<i32, 8>

source§

fn from(value: __m256i) -> Simd<i32, 8>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<i64, 4>

source§

fn from(value: __m256i) -> Simd<i64, 4>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<i8, 32>

source§

fn from(value: __m256i) -> Simd<i8, 32>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<isize, 4>

source§

fn from(value: __m256i) -> Simd<isize, 4>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<u16, 16>

source§

fn from(value: __m256i) -> Simd<u16, 16>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<u32, 8>

source§

fn from(value: __m256i) -> Simd<u32, 8>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<u64, 4>

source§

fn from(value: __m256i) -> Simd<u64, 4>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<u8, 32>

source§

fn from(value: __m256i) -> Simd<u8, 32>

Converts to this type from the input type.
source§

impl From<__m256i> for Simd<usize, 4>

source§

fn from(value: __m256i) -> Simd<usize, 4>

Converts to this type from the input type.
source§

impl From<__m512> for Simd<f32, 16>

source§

fn from(value: __m512) -> Simd<f32, 16>

Converts to this type from the input type.
source§

impl From<__m512d> for Simd<f64, 8>

source§

fn from(value: __m512d) -> Simd<f64, 8>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<i16, 32>

source§

fn from(value: __m512i) -> Simd<i16, 32>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<i32, 16>

source§

fn from(value: __m512i) -> Simd<i32, 16>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<i64, 8>

source§

fn from(value: __m512i) -> Simd<i64, 8>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<i8, 64>

source§

fn from(value: __m512i) -> Simd<i8, 64>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<isize, 8>

source§

fn from(value: __m512i) -> Simd<isize, 8>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<u16, 32>

source§

fn from(value: __m512i) -> Simd<u16, 32>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<u32, 16>

source§

fn from(value: __m512i) -> Simd<u32, 16>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<u64, 8>

source§

fn from(value: __m512i) -> Simd<u64, 8>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<u8, 64>

source§

fn from(value: __m512i) -> Simd<u8, 64>

Converts to this type from the input type.
source§

impl From<__m512i> for Simd<usize, 8>

source§

fn from(value: __m512i) -> Simd<usize, 8>

Converts to this type from the input type.
source§

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

source§

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

Formats the value using the given formatter.
source§

impl<T, const LANES: usize> LowerHex for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + LowerHex,

source§

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

Formats the value using the given formatter.
source§

impl<'lhs, 'rhs, T, const LANES: usize> Mul<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Mul<&'rhs Simd<T, LANES>>>::Output

Performs the * 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<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<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<f32, N>

The resulting type after applying the * operator.
source§

fn mul(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Mul<Simd<f32, N>>>::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<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<i32, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<i64, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<i8, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<isize, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<u16, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<u32, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<u64, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<u8, N>

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

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

§

type Output = Simd<usize, N>

The resulting type after applying the * operator.
source§

fn mul( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Mul<Simd<usize, 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<f32, LANES>where f32: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<f32, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - 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<const LANES: usize> Neg for Simd<i16, LANES>where i16: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<i16, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

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

§

type Output = Simd<i32, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

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

§

type Output = Simd<i64, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

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

§

type Output = Simd<i8, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

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

§

type Output = Simd<isize, LANES>

The resulting type after applying the - operator.
source§

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

Performs the unary - operation. Read more
source§

impl<const LANES: usize> Not for Simd<i16, LANES>where i16: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<i16, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<i16, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<i32, LANES>where i32: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<i32, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<i32, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<i64, LANES>where i64: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<i64, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<i64, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<i8, LANES>where i8: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<i8, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<i8, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<isize, LANES>where isize: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<isize, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<isize, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<u16, LANES>where u16: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<u16, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<u16, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<u32, LANES>where u32: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<u32, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<u32, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<u64, LANES>where u64: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<u64, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<u64, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<u8, LANES>where u8: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<u8, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<u8, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<const LANES: usize> Not for Simd<usize, LANES>where usize: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

type Output = Simd<usize, LANES>

The resulting type after applying the ! operator.
source§

fn not(self) -> <Simd<usize, LANES> as Not>::Output

Performs the unary ! operation. Read more
source§

impl<T, const LANES: usize> Octal for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Octal,

source§

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

Formats the value using the given formatter.
source§

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

source§

fn cmp(&self, other: &Simd<T, LANES>) -> 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 LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + PartialEq<T>,

source§

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

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

fn ne(&self, other: &Simd<T, LANES>) -> 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 LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + PartialOrd<T>,

source§

fn partial_cmp(&self, other: &Simd<T, LANES>) -> 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<f32, LANES>> for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

Method which takes an iterator and generates Self from the elements by multiplying the items.
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<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

source§

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

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

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

source§

fn product<I>(iter: I) -> Simd<f32, LANES>where I: Iterator<Item = Simd<f32, 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<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

impl<'lhs, 'rhs, T, const LANES: usize> Rem<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Rem<&'rhs Simd<T, LANES>>>::Output

Performs the % operation. Read more
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<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<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<f32, N>

The resulting type after applying the % operator.
source§

fn rem(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Rem<Simd<f32, N>>>::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<const N: usize> Rem<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<i32, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<i64, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<i8, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<isize, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<u16, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<u32, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<u64, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<u8, N>

The resulting type after applying the % operator.
source§

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

Performs the % operation. Read more
source§

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

§

type Output = Simd<usize, N>

The resulting type after applying the % operator.
source§

fn rem( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Rem<Simd<usize, 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<'lhs, 'rhs, T, const LANES: usize> Shl<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Shl<&'rhs Simd<T, LANES>>>::Output

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, 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<const N: usize> Shl<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i32, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i64, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i8, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<isize, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u16, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

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

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

Performs the << operation. Read more
source§

impl<const N: usize> Shl<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

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

fn shl( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Shl<Simd<usize, N>>>::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<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Shr<&'rhs Simd<T, LANES>>>::Output

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, 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<const N: usize> Shr<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i32, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i64, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i8, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<isize, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u16, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

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

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

Performs the >> operation. Read more
source§

impl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

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

fn shr( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Shr<Simd<usize, N>>>::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<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

type Scalar = f32

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

type Bits = Simd<u32, LANES>

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

fn to_bits(self) -> Simd<u32, LANES>

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

fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>

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

fn abs(self) -> Simd<f32, LANES>

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

fn recip(self) -> Simd<f32, LANES>

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

fn to_degrees(self) -> Simd<f32, LANES>

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

fn to_radians(self) -> Simd<f32, LANES>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn signum(self) -> Simd<f32, LANES>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the minimum lane in the vector. 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)
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, LANES>

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

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

🔬This is a nightly-only experimental API. (portable_simd)
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)
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)
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)
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)
Converts each lane from radians to degrees.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
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)
Returns true for each lane 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, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each lane if it has a negative sign, including -0.0, NaNs 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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
Returns the minimum lane in the vector. Read more
source§

impl<const LANES: usize> SimdInt for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

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

type Scalar = i16

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

fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value. Read more
source§

fn saturating_abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself. Read more
source§

fn saturating_neg(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself. Read more
source§

fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each positive lane and false if it is zero or negative.
source§

fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each negative lane and false if it is zero or positive.
source§

fn signum(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Returns numbers representing the sign of each lane. Read more
source§

fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition. Read more
source§

fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication. Read more
source§

fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

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

fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

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

fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdInt for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

type Scalar = i32

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

fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value. Read more
source§

fn saturating_abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself. Read more
source§

fn saturating_neg(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself. Read more
source§

fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each positive lane and false if it is zero or negative.
source§

fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each negative lane and false if it is zero or positive.
source§

fn signum(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Returns numbers representing the sign of each lane. Read more
source§

fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition. Read more
source§

fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication. Read more
source§

fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

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

fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

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

fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdInt for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

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

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

type Scalar = i64

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

fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value. Read more
source§

fn saturating_abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself. Read more
source§

fn saturating_neg(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself. Read more
source§

fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each positive lane and false if it is zero or negative.
source§

fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each negative lane and false if it is zero or positive.
source§

fn signum(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Returns numbers representing the sign of each lane. Read more
source§

fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition. Read more
source§

fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication. Read more
source§

fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

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

fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

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

fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdInt for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

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

type Scalar = i8

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

fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value. Read more
source§

fn saturating_abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself. Read more
source§

fn saturating_neg(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself. Read more
source§

fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each positive lane and false if it is zero or negative.
source§

fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each negative lane and false if it is zero or positive.
source§

fn signum(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Returns numbers representing the sign of each lane. Read more
source§

fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition. Read more
source§

fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication. Read more
source§

fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

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

fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

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

fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdInt for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

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

type Scalar = isize

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

fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value. Read more
source§

fn saturating_abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself. Read more
source§

fn saturating_neg(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself. Read more
source§

fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each positive lane and false if it is zero or negative.
source§

fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd)
Returns true for each negative lane and false if it is zero or positive.
source§

fn signum(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Returns numbers representing the sign of each lane. Read more
source§

fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition. Read more
source§

fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication. Read more
source§

fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

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

fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

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

fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdOrd for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

impl<const LANES: usize> SimdOrd for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise maximum with other.
source§

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

🔬This is a nightly-only experimental API. (portable_simd)
Returns the lane-wise minimum with other.
source§

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

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

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

§

type Mask = Mask<<f32 as SimdElement>::Mask, LANES>

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

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

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

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

🔬This is a nightly-only experimental API. (portable_simd)
Test if each lane is equal to the corresponding lane in other.
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)
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)
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)
Test if each lane is equal to the corresponding lane in other.
source§

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

§

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

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

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

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

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

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

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

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

§

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<u16 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<u32 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<u64 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<u8 as SimdElement>::Mask, LANES>

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

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

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

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

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

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

§

type Mask = Mask<<usize as SimdElement>::Mask, LANES>

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

🔬This is a nightly-only experimental API. (portable_simd)
Test if each lane is greater than or 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)
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)
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)
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)
Test if each lane is greater than or equal to the corresponding lane in other.
source§

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

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

source§

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

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

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

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

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

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

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

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

impl<const LANES: usize> SimdUint for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Scalar = u16

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

fn saturating_add(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn reduce_sum(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

fn reduce_product(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

fn reduce_max(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

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

fn reduce_min(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

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

fn reduce_and(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdUint for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Scalar = u32

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

fn saturating_add(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn reduce_sum(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

fn reduce_product(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

fn reduce_max(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

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

fn reduce_min(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

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

fn reduce_and(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdUint for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Scalar = u64

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

fn saturating_add(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn reduce_sum(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

fn reduce_product(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

fn reduce_max(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

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

fn reduce_min(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

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

fn reduce_and(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdUint for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Scalar = u8

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

fn saturating_add(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn reduce_sum(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

fn reduce_product(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

fn reduce_max(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

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

fn reduce_min(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

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

fn reduce_and(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

impl<const LANES: usize> SimdUint for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Scalar = usize

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

fn saturating_add(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating add. Read more
source§

fn saturating_sub(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd)
Lanewise saturating subtract. Read more
source§

fn reduce_sum(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

fn reduce_product(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

fn reduce_max(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

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

fn reduce_min(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

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

fn reduce_and(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

fn reduce_or(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

fn reduce_xor(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

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

source§

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

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

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)
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 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)
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)
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)
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<const N: usize> StdFloat for Simd<f64, N>where LaneCount<N>: SupportedLaneCount,

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 mul_add(self, a: Self, b: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)
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 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)
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)
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)
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<'lhs, 'rhs, T, const LANES: usize> Sub<&'rhs Simd<T, LANES>> for &'lhs 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> ) -> <&'lhs Simd<T, LANES> as Sub<&'rhs Simd<T, LANES>>>::Output

Performs the - operation. Read more
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<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<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<f32, N>

The resulting type after applying the - operator.
source§

fn sub(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Sub<Simd<f32, N>>>::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<const N: usize> Sub<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<i16, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<i32, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<i64, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<i8, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<isize, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<u16, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<u32, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<u64, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<u8, N>

The resulting type after applying the - operator.
source§

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

Performs the - operation. Read more
source§

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

§

type Output = Simd<usize, N>

The resulting type after applying the - operator.
source§

fn sub( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Sub<Simd<usize, 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<f32, LANES>> for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

Method which takes an iterator and generates Self from the elements by “summing up” the items.
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<'a, const LANES: usize> Sum<&'a Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

fn sum<I>(iter: I) -> Simd<f32, LANES>where I: Iterator<Item = Simd<f32, 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<const LANES: usize> Sum<Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

impl<T, const LANES: usize> UpperExp for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + UpperExp,

source§

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

Formats the value using the given formatter.
source§

impl<T, const LANES: usize> UpperHex for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + UpperHex,

source§

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

Formats the value using the given formatter.
source§

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

source§

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

Auto Trait Implementations§

§

impl<T, const LANES: usize> RefUnwindSafe for Simd<T, LANES>where T: RefUnwindSafe,

§

impl<T, const LANES: usize> Send for Simd<T, LANES>where T: Send,

§

impl<T, const LANES: usize> Sync for Simd<T, LANES>where T: Sync,

§

impl<T, const LANES: usize> Unpin for Simd<T, LANES>where T: Unpin,

§

impl<T, const LANES: usize> UnwindSafe for Simd<T, LANES>where T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32 ) -> TaggedParser<'a, Implicit, Self, E>

source§

impl<T> Borrow<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.
§

impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for Twhere U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> Pointable for T

§

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same<T> for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
source§

impl<M> Measure for Mwhere M: Debug + PartialOrd<M> + Add<M, Output = M> + Default + Clone,

source§

impl<N> NodeTrait for Nwhere N: Copy + Ord + Hash,

source§

impl<T, Rhs> NumAssignOps<Rhs> for Twhere T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,

source§

impl<T, Rhs, Output> NumOps<Rhs, Output> for Twhere T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,

source§

impl<T, Base> RefNum<Base> for Twhere T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,