Struct core::simd::Simd

#[repr(simd)]
pub struct Simd<T, const LANES: usize>(_)
 where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount;

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

T 类型的 LANES 元素的 SIMD vector。

Implementations

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

pub fn horizontal_sum(self) -> i8

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> i8

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> i8

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> i8

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> i16

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> i16

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> i16

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> i16

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> i32

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> i32

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> i32

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> i32

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> i64

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> i64

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> i64

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> i64

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> isize

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> isize

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> isize

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> isize

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> u8

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> u8

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> u8

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> u8

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> u16

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> u16

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> u16

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> u16

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> u32

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> u32

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> u32

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> u32

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> u64

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> u64

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> u64

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> u64

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> usize

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

Horizontal 包装加法。返回 vector 的 lane 总和，带包装加法。

pub fn horizontal_product(self) -> usize

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

Horizontal 包装乘法。返回 vector 的 lane 的乘积，带包装乘法。

pub fn horizontal_max(self) -> usize

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

Horizontal 最大值。返回 vector 中的最大 lane。

pub fn horizontal_min(self) -> usize

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

Horizontal 最小值。返回 vector 中的最小 lane。

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

pub fn horizontal_sum(self) -> f32

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

Horizontal 加法。返回 vector 的 lane 的总和。

pub fn horizontal_product(self) -> f32

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

Horizontal 乘法。返回 vector 的 lanes 的乘积。

pub fn horizontal_max(self) -> f32

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

Horizontal 最大值。返回 vector 中的最大 lane。

返回基于相等的值，因此包含 0. 和 -0. 的 vector 可以返回任意一个值。 这个函数不会返回 NaN，除非所有的 lane 都是 NaN。

pub fn horizontal_min(self) -> f32

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

Horizontal 最小值。返回 vector 中的最小 lane。

返回基于相等的值，因此包含 0. 和 -0. 的 vector 可以返回任意一个值。 这个函数不会返回 NaN，除非所有的 lane 都是 NaN。

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

pub fn horizontal_sum(self) -> f64

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

Horizontal 加法。返回 vector 的 lane 的总和。

pub fn horizontal_product(self) -> f64

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

Horizontal 乘法。返回 vector 的 lanes 的乘积。

pub fn horizontal_max(self) -> f64

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

Horizontal 最大值。返回 vector 中的最大 lane。

返回基于相等的值，因此包含 0. 和 -0. 的 vector 可以返回任意一个值。 这个函数不会返回 NaN，除非所有的 lane 都是 NaN。

pub fn horizontal_min(self) -> f64

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

Horizontal 最小值。返回 vector 中的最小 lane。

返回基于相等的值，因此包含 0. 和 -0. 的 vector 可以返回任意一个值。 这个函数不会返回 NaN，除非所有的 lane 都是 NaN。

impl<T, const LANES: usize> Simd<T, LANES> where
    Self: BitAnd<Self, Output = Self>,
    T: SimdElement + BitAnd<T, Output = T>,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_and(self) -> T

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

Horizontal 按位与。 返回跨 vector lane 的累积按位与。

impl<T, const LANES: usize> Simd<T, LANES> where
    Self: BitOr<Self, Output = Self>,
    T: SimdElement + BitOr<T, Output = T>,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_or(self) -> T

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

Horizontal 按位或。 返回跨 vector lane 的累积按位或。

impl<T, const LANES: usize> Simd<T, LANES> where
    Self: BitXor<Self, Output = Self>,
    T: SimdElement + BitXor<T, Output = T>,
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_xor(self) -> T

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

Horizontal 按位异或。 返回跨 vector lane 的累积按位异或。

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

pub fn reverse(self) -> Self

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

反转 vector 中 lanes 的顺序。

pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Self

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

旋转 vector，使切片的第一个 OFFSET 元素移动到末尾，而最后一个 LANES - OFFSET 元素移动到前面。

调用 rotate_lanes_left 后，先前在 OFFSET lane 中的元素将成为该 lane 中的第一个元素。

pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Self

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

旋转 vector，使 vector 的第一个 LANES - OFFSET 元素移动到末尾，而最后一个 OFFSET 元素移动到前面。

调用 rotate_lanes_right 后，之前位于索引 LANES - OFFSET 的元素将成为切片中的第一个元素。

pub fn interleave(self, other: Self) -> (Self, Self)

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

交错两个 vectors。

产生两个 vectors，其中 lanes 交替取自 self 和 other。

第一个结果包含来自 self 和 other 的第一个 LANES / 2 lanes，交替地从 self 的第一个 lane 开始。

第二个结果包含来自 self 和 other 的最后一个 LANES / 2 lanes，交替，从 self 开始的 lane LANES / 2 开始。

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

pub fn deinterleave(self, other: Self) -> (Self, Self)

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

去交错两个 vectors。

第一个结果取 self 的每隔一个 lane，然后是 other，从第一个 lane 开始。

第二个结果取 self 的每隔一个 lane，然后是 other，从第二个 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]);

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

pub fn lanes_eq(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否等于 other 中对应的 lane。

pub fn lanes_ne(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否不等于 other 中对应的 lane。

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

pub fn lanes_lt(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否小于 other 中对应的 lane。

pub fn lanes_gt(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否大于 other 中对应的 lane。

pub fn lanes_le(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否小于或等于 other 中对应的 lane。

pub fn lanes_ge(self, other: Self) -> Mask<T::Mask, LANES>

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

测试每个 lane 是否大于或等于 other 中对应的 lane。

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

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

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

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

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

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

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

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

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

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

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

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

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

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

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

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

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

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

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

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

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

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

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

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

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

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

pub fn saturating_add(self, second: Self) -> Self

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

Lanewise 饱和加法。

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Self) -> Self

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

Lanewise 饱和减法。

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Self

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

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Self

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

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Self

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

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

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

pub unsafe fn to_int_unchecked(self) -> Simd<i32, LANES>

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

向零舍入并转换为等宽整数类型，假设该值是有限的并且适合该类型。

Safety

该值必须：

• 不是 NaN
• 不是无限的
• 在截断其小数部分后，可以在返回类型中表示

pub fn round_from_int(value: Simd<i32, LANES>) -> Self

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

从整数 vector 创建一个浮点 vector。 舍入不能完全表示的值。

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

pub unsafe fn to_int_unchecked(self) -> Simd<i64, LANES>

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

向零舍入并转换为等宽整数类型，假设该值是有限的并且适合该类型。

Safety

该值必须：

• 不是 NaN
• 不是无限的
• 在截断其小数部分后，可以在返回类型中表示

pub fn round_from_int(value: Simd<i64, LANES>) -> Self

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

从整数 vector 创建一个浮点 vector。 舍入不能完全表示的值。

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

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

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

原始转换为无符号整数 vector 类型，其大小和数量与 lanes 相同。

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

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

来自具有相同大小和数量的 lanes 的无符号整数 vector 类型的原始变换。

pub fn abs(self) -> Self

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

生成一个 vector，其中每个 lane 都具有 self 中等效索引 lane 的绝对值。

pub fn recip(self) -> Self

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

获取每个 lane 的倒数 (inverse)，1/x。

pub fn to_degrees(self) -> Self

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

将每个 lane 从弧度转换为度数。

pub fn to_radians(self) -> Self

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

将每个 lane 从度数转换为弧度。

pub fn is_sign_positive(self) -> Mask<i32, LANES>

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

如果每个 lane 具有正号，则为每个 lane 返回 true，包括 +0.0、具有正符号位的 NaN 和正无穷大。

pub fn is_sign_negative(self) -> Mask<i32, LANES>

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

如果每个 lane 具有负号，则为每个 lane 返回 true，包括 -0.0、具有负符号位的 NaN 和负无穷大。

pub fn is_nan(self) -> Mask<i32, LANES>

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

如果每个 lane 的值为 NaN，则为每个 lane 返回 true。

pub fn is_infinite(self) -> Mask<i32, LANES>

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

如果每个 lane 的值是正无穷大或负无穷大，则为每个 lane 返回 true。

pub fn is_finite(self) -> Mask<i32, LANES>

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

如果每个 lane 的值既不是无穷大也不是 NaN，则为每个 lane 返回 true。

pub fn is_subnormal(self) -> Mask<i32, LANES>

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

如果每个 lane 的值为 subnormal，则为每个 lane 返回 true。

pub fn is_normal(self) -> Mask<i32, LANES>

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

如果每个 lane 的值既不是零、无穷大、subnormal 或 NaN，则为每个 lane 返回 true。

pub fn signum(self) -> Self

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

用代表其符号的数字替换每个 lane。

• 1.0 如果数字是正数，+0.0 或 INFINITY
• -1.0 如果数字是负数，-0.0 或 NEG_INFINITY
• NAN 如果数字是 NAN

pub fn copysign(self, sign: Self) -> Self

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

以 self 的大小和 sign 的符号返回每个 lane。

如果任何 lane 是 NAN，则返回带有 sign 符号的 NAN。

pub fn min(self, other: Self) -> Self

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

返回每个 lane 的最小值。

如果其中一个值为 NAN，则返回另一个值。

pub fn max(self, other: Self) -> Self

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

返回每个 lane 的最大值。

如果其中一个值为 NAN，则返回另一个值。

pub fn clamp(self, min: Self, max: Self) -> Self

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

将每个 lane 限制在一定的区间内，除非它是 NaN。

对于 self 中的每个 lane，如果 lane 大于 max，则返回 max 中对应的 lane，如果 lane 小于 min，则返回 min 中对应的 lane。 否则返回 self 中的 lane。

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

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

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

原始转换为无符号整数 vector 类型，其大小和数量与 lanes 相同。

pub fn from_bits(bits: Simd<u64, LANES>) -> Self

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

来自具有相同大小和数量的 lanes 的无符号整数 vector 类型的原始变换。

pub fn abs(self) -> Self

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

生成一个 vector，其中每个 lane 都具有 self 中等效索引 lane 的绝对值。

pub fn recip(self) -> Self

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

获取每个 lane 的倒数 (inverse)，1/x。

pub fn to_degrees(self) -> Self

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

将每个 lane 从弧度转换为度数。

pub fn to_radians(self) -> Self

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

将每个 lane 从度数转换为弧度。

pub fn is_sign_positive(self) -> Mask<i64, LANES>

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

如果每个 lane 具有正号，则为每个 lane 返回 true，包括 +0.0、具有正符号位的 NaN 和正无穷大。

pub fn is_sign_negative(self) -> Mask<i64, LANES>

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

如果每个 lane 具有负号，则为每个 lane 返回 true，包括 -0.0、具有负符号位的 NaN 和负无穷大。

pub fn is_nan(self) -> Mask<i64, LANES>

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

如果每个 lane 的值为 NaN，则为每个 lane 返回 true。

pub fn is_infinite(self) -> Mask<i64, LANES>

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

如果每个 lane 的值是正无穷大或负无穷大，则为每个 lane 返回 true。

pub fn is_finite(self) -> Mask<i64, LANES>

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

如果每个 lane 的值既不是无穷大也不是 NaN，则为每个 lane 返回 true。

pub fn is_subnormal(self) -> Mask<i64, LANES>

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

如果每个 lane 的值为 subnormal，则为每个 lane 返回 true。

pub fn is_normal(self) -> Mask<i64, LANES>

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

如果每个 lane 的值既不是零、无穷大、subnormal 或 NaN，则为每个 lane 返回 true。

pub fn signum(self) -> Self

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

用代表其符号的数字替换每个 lane。

• 1.0 如果数字是正数，+0.0 或 INFINITY
• -1.0 如果数字是负数，-0.0 或 NEG_INFINITY
• NAN 如果数字是 NAN

pub fn copysign(self, sign: Self) -> Self

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

以 self 的大小和 sign 的符号返回每个 lane。

如果任何 lane 是 NAN，则返回带有 sign 符号的 NAN。

pub fn min(self, other: Self) -> Self

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

返回每个 lane 的最小值。

如果其中一个值为 NAN，则返回另一个值。

pub fn max(self, other: Self) -> Self

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

返回每个 lane 的最大值。

如果其中一个值为 NAN，则返回另一个值。

pub fn clamp(self, min: Self, max: Self) -> Self

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

将每个 lane 限制在一定的区间内，除非它是 NaN。

对于 self 中的每个 lane，如果 lane 大于 max，则返回 max 中对应的 lane，如果 lane 小于 min，则返回 min 中对应的 lane。 否则返回 self 中的 lane。

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

pub fn is_positive(self) -> Mask<isize, LANES>

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

对于每个正 lane 返回真，如果为零或负则返回假。

pub fn is_negative(self) -> Mask<isize, LANES>

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

对于每个负 lane 返回 true，如果为零或正则返回 false。

pub fn signum(self) -> Self

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

返回代表每个 lane 符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

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

pub fn is_positive(self) -> Mask<i16, LANES>

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

对于每个正 lane 返回真，如果为零或负则返回假。

pub fn is_negative(self) -> Mask<i16, LANES>

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

对于每个负 lane 返回 true，如果为零或正则返回 false。

pub fn signum(self) -> Self

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

返回代表每个 lane 符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

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

pub fn is_positive(self) -> Mask<i32, LANES>

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

对于每个正 lane 返回真，如果为零或负则返回假。

pub fn is_negative(self) -> Mask<i32, LANES>

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

对于每个负 lane 返回 true，如果为零或正则返回 false。

pub fn signum(self) -> Self

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

返回代表每个 lane 符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

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

pub fn is_positive(self) -> Mask<i64, LANES>

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

对于每个正 lane 返回真，如果为零或负则返回假。

pub fn is_negative(self) -> Mask<i64, LANES>

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

对于每个负 lane 返回 true，如果为零或正则返回 false。

pub fn signum(self) -> Self

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

返回代表每个 lane 符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

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

pub fn is_positive(self) -> Mask<i8, LANES>

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

对于每个正 lane 返回真，如果为零或负则返回假。

pub fn is_negative(self) -> Mask<i8, LANES>

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

对于每个负 lane 返回 true，如果为零或正则返回 false。

pub fn signum(self) -> Self

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

返回代表每个 lane 符号的数字。

• 0 如果数字为零
• 1 如果数字是正数
• -1 如果数字是负数

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

pub const LANES: usize

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

此 vector 中 lanes 的数量。

pub const fn lanes(&self) -> usize

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

获取此 vector 中 lanes 的数量。

pub const fn splat(value: T) -> Self

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

通过将所有 lane 设置为给定值来构建 SIMD vector。

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

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

返回包含整个 SIMD vector 的数组引用。

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

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

返回一个包含整个 SIMD vector 的可变数组引用。

pub const fn from_array(array: [T; LANES]) -> Self

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

将数组转换为 SIMD vector。

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

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

将 SIMD vector 转换为数组。

pub const fn from_slice(slice: &[T]) -> Self

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

将切片转换为包含 slice[..LANES] 的 SIMD vector

Panics

如果切片的 len 小于 vector 的 Simd::LANES，则 from_slice 会出现 panic。

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

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

从 slice 中可能不连续的索引读取以构建 SIMD vector。 如果索引越界，则改为从 or vector 中选择 lane。

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); // 注意越界的 lane。
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));

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

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

从 slice 中可能不连续的索引读取以构建 SIMD vector。 如果索引越界，则 lane 将设置为该类型的默认值。

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); // 注意越界的 lane。
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));

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

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

从 slice 中可能不连续的索引读取以构建 SIMD vector。 掩码 enable 所有 true lane 并禁用所有 false lane。 如果索引被禁用或越界，则从 or vector 中选择 lane。

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]); // 注意最后一个 lane 的掩码。

let result = Simd::gather_select(&vec, enable, idxs, alt); // 注意越界的 lane。
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

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

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

从 slice 中可能不连续的索引读取以构建 SIMD vector。 掩码 enable 所有 true lane 并禁用所有 false lane。 如果禁用某个索引，则从 or vector 中选择 lane。

Safety

使用 enabled 越界索引调用这个函数是 未定义的行为，即使结果值没有被使用。

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]); // 注意最后的掩码 lane。
// 如果用这个掩码来收集，这是不合理的。让我们解决这个问题。
let enable = enable & idxs.lanes_lt(Simd::splat(vec.len()));

// 我们已经屏蔽了 OOB lane，所以现在可以安全收集了。
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

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

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

将 SIMD vector 中的值写入 slice 中可能不连续的索引。 如果分散的 vector 中的两个 lanes 将写入相同的索引，则只能保证实际写入最后一个 lane。

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); // 索引 0 接收两次写入。
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);

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

将 SIMD vector 中的值写入 slice 中的多个可能不连续的索引。 掩码 enable 所有 true lane 并禁用所有 false lane。 如果启用的索引越界，则不会写入 lane。 如果分散的 vector 中的两个启用的 lanes 将写入同一个索引，则只能保证实际写入最后一个 lane。

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]); // 注意最后一个 lane 的掩码。

vals.scatter_select(&mut vec, enable, idxs); // 索引 0 的第二次写入被屏蔽，因此被省略。
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

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

将 SIMD vector 中的值写入 slice 中的多个可能不连续的索引。 掩码 enable 所有 true lane 并禁用所有 false lane。 如果分散的 vector 中的两个启用的 lanes 将写入同一个索引，则只能保证实际写入最后一个 lane。

Safety

使用启用的越界索引调用此函数是 [undefined 行为]，并可能导致内存损坏。

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]); // 注意最后一个 lane 的掩码。
// 如果用这个掩码来分散，这是不合理的。让我们解决这个问题。
let enable = enable & idxs.lanes_lt(Simd::splat(vec.len()));

// 我们已经屏蔽了 OOB lane，所以现在可以安全地分散了。
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// 索引 0 的第二次写入被屏蔽，因此被省略。
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

Trait Implementations

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>

应用 + 运算符后的结果类型。

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

执行 + 操作。

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>

应用 + 运算符后的结果类型。

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

执行 + 操作。

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>

应用 + 运算符后的结果类型。

fn add(self, rhs: Simd<T, LANES>) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

type Output = Self

应用 + 运算符后的结果类型。

fn add(self, rhs: Self) -> Self::Output

执行 + 操作。

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

fn add_assign(&mut self, rhs: U)

执行 += 操作。

impl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

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

执行转换。

impl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

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

执行转换。

impl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

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

执行转换。

impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

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

执行转换。

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

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

使用给定的格式化程序格式化该值。

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>

应用 & 运算符后的结果类型。

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

执行 & 操作。

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>

应用 & 运算符后的结果类型。

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

执行 & 操作。

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>

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Simd<T, LANES>) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

type Output = Self

应用 & 运算符后的结果类型。

fn bitand(self, rhs: Self) -> Self::Output

执行 & 操作。

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

fn bitand_assign(&mut self, rhs: U)

执行 &= 操作。

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>

应用 | 运算符后的结果类型。

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

执行 | 操作。

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>

应用 | 运算符后的结果类型。

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

执行 | 操作。

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>

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Simd<T, LANES>) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

type Output = Self

应用 | 运算符后的结果类型。

fn bitor(self, rhs: Self) -> Self::Output

执行 | 操作。

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

fn bitor_assign(&mut self, rhs: U)

执行 |= 操作。

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>

应用 ^ 运算符后的结果类型。

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

执行 ^ 操作。

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>

应用 ^ 运算符后的结果类型。

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

执行 ^ 操作。

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>

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Simd<T, LANES>) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

type Output = Self

应用 ^ 运算符后的结果类型。

fn bitxor(self, rhs: Self) -> Self::Output

执行 ^ 操作。

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

fn bitxor_assign(&mut self, rhs: U)

执行 ^= 操作。

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

fn clone(&self) -> Self

返回值的副本。

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

从 source 执行复制分配。

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

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

使用给定的格式化程序格式化该值。

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

fn default() -> Self

返回类型的 “默认值”。

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>

应用 / 运算符后的结果类型。

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

执行 / 操作。

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>

应用 / 运算符后的结果类型。

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

执行 / 操作。

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>

应用 / 运算符后的结果类型。

fn div(self, rhs: Simd<T, LANES>) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

type Output = Self

应用 / 运算符后的结果类型。

fn div(self, rhs: Self) -> Self::Output

执行 / 操作。

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

fn div_assign(&mut self, rhs: U)

执行 /= 操作。

impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES> where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn from(array: [T; LANES]) -> Self

执行转换。

impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES] where
    LaneCount<LANES>: SupportedLaneCount,
    T: SimdElement, 

fn from(vector: Simd<T, LANES>) -> Self

执行转换。

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

fn from(value: f32x16) -> __m512

执行转换。

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

fn from(value: f32x4) -> __m128

执行转换。

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

fn from(value: f32x8) -> __m256

执行转换。

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

fn from(value: f64x2) -> __m128d

执行转换。

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

fn from(value: f64x4) -> __m256d

执行转换。

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

fn from(value: f64x8) -> __m512d

执行转换。

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

fn from(value: i16x16) -> __m256i

执行转换。

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

fn from(value: i16x32) -> __m512i

执行转换。

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

fn from(value: i16x8) -> __m128i

执行转换。

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

fn from(value: i32x16) -> __m512i

执行转换。

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

fn from(value: i32x4) -> __m128i

执行转换。

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

fn from(value: i32x8) -> __m256i

执行转换。

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

fn from(value: i64x2) -> __m128i

执行转换。

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

fn from(value: i64x4) -> __m256i

执行转换。

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

fn from(value: i64x8) -> __m512i

执行转换。

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

fn from(value: i8x16) -> __m128i

执行转换。

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

fn from(value: i8x32) -> __m256i

执行转换。

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

fn from(value: i8x64) -> __m512i

执行转换。

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

fn from(value: isizex2) -> __m128i

执行转换。

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

fn from(value: isizex4) -> __m256i

执行转换。

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

fn from(value: isizex8) -> __m512i

执行转换。

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

fn from(value: u16x16) -> __m256i

执行转换。

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

fn from(value: u16x32) -> __m512i

执行转换。

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

fn from(value: u16x8) -> __m128i

执行转换。

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

fn from(value: u32x16) -> __m512i

执行转换。

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

fn from(value: u32x4) -> __m128i

执行转换。

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

fn from(value: u32x8) -> __m256i

执行转换。

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

fn from(value: u64x2) -> __m128i

执行转换。

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

fn from(value: u64x4) -> __m256i

执行转换。

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

fn from(value: u64x8) -> __m512i

执行转换。

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

fn from(value: u8x16) -> __m128i

执行转换。

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

fn from(value: u8x32) -> __m256i

执行转换。

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

fn from(value: u8x64) -> __m512i

执行转换。

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

fn from(value: usizex2) -> __m128i

执行转换。

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

fn from(value: usizex4) -> __m256i

执行转换。

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

fn from(value: usizex8) -> __m512i

执行转换。

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

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

将该值输入给定的 Hasher。

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

将这种类型的切片送入给定的 Hasher 中。

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

type Output = I::Output

索引后返回的类型。

fn index(&self, index: I) -> &Self::Output

执行索引 (container[index]) 操作。

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

fn index_mut(&mut self, index: I) -> &mut Self::Output

执行可变索引 (container[index]) 操作。

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

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

使用给定的格式化程序格式化该值。

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

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

使用给定的格式化程序格式化该值。

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>

应用 * 运算符后的结果类型。

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

执行 * 操作。

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>

应用 * 运算符后的结果类型。

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

执行 * 操作。

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>

应用 * 运算符后的结果类型。

fn mul(self, rhs: Simd<T, LANES>) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

type Output = Self

应用 * 运算符后的结果类型。

fn mul(self, rhs: Self) -> Self::Output

执行 * 操作。

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

fn mul_assign(&mut self, rhs: U)

执行 *= 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 - 运算符后的结果类型。

fn neg(self) -> Self::Output

执行一元 - 运算。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

type Output = Self

应用 ! 运算符后的结果类型。

fn not(self) -> Self::Output

执行一元 ! 操作。

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

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

使用给定的格式化程序格式化该值。

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

fn cmp(&self, other: &Self) -> Ordering

此方法返回 self 和 other 之间的 Ordering。

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

比较并返回两个值中的最大值。

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

比较并返回两个值中的最小值。

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

将值限制在某个时间间隔内。

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

fn eq(&self, other: &Self) -> bool

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

如果存在，则此方法返回 self 和 other 值之间的顺序。

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

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

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

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

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

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

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

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

该方法采用迭代器并通过乘以项从元素生成 Self。

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>

应用 % 运算符后的结果类型。

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

执行 % 操作。

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>

应用 % 运算符后的结果类型。

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

执行 % 操作。

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>

应用 % 运算符后的结果类型。

fn rem(self, rhs: Simd<T, LANES>) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

type Output = Self

应用 % 运算符后的结果类型。

fn rem(self, rhs: Self) -> Self::Output

执行 % 操作。

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

fn rem_assign(&mut self, rhs: U)

执行 %= 操作。

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>

应用 << 运算符后的结果类型。

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

执行 << 操作。

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>

应用 << 运算符后的结果类型。

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

执行 << 操作。

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>

应用 << 运算符后的结果类型。

fn shl(self, rhs: Simd<T, LANES>) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

type Output = Self

应用 << 运算符后的结果类型。

fn shl(self, rhs: Self) -> Self::Output

执行 << 操作。

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

fn shl_assign(&mut self, rhs: U)

执行 <<= 操作。

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>

应用 >> 运算符后的结果类型。

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

执行 >> 操作。

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>

应用 >> 运算符后的结果类型。

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

执行 >> 操作。

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>

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Simd<T, LANES>) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

type Output = Self

应用 >> 运算符后的结果类型。

fn shr(self, rhs: Self) -> Self::Output

执行 >> 操作。

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

fn shr_assign(&mut self, rhs: U)

执行 >>= 操作。

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>

应用 - 运算符后的结果类型。

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

执行 - 操作。

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>

应用 - 运算符后的结果类型。

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

执行 - 操作。

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>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<T, LANES>) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

type Output = Self

应用 - 运算符后的结果类型。

fn sub(self, rhs: Self) -> Self::Output

执行 - 操作。

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

fn sub_assign(&mut self, rhs: U)

执行 -= 操作。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

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

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

使用给定的格式化程序格式化该值。

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

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

使用给定的格式化程序格式化该值。

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

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