Struct std::simd::Simd

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

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

具有 [T; N] 形状但 T 操作的 SIMD vector。

Simd<T, N> 支持 T 以 “elementwise” 方式执行的运算符 (+、* 等)。 它们从左侧和右侧获取每个索引处的元素，执行操作，然后将结果返回到相同大小的 vector 中的相同索引中。 但是，Simd 不同于普通迭代和普通数组:

• Simd<T, N> 在没有 break 的情况下单步执行 N 操作
• Simd<T, N> 的对齐方式可以大于 T，以获得更好的机械一致性

通过始终对 Simd 施加这些约束，可以更轻松地将逐元素操作编译为可以在并行中执行的机器指令。

let a: [i32; 4] = [-2, 0, 2, 4];
let b = [10, 9, 8, 7];
let sum = array::from_fn(|i| a[i] + b[i]);
let prod = array::from_fn(|i| a[i] * b[i]);

// `Simd<T, N>` 实现 `From<[T; N]>`
let (v, w) = (Simd::from(a), Simd::from(b));
// 这意味着数组实现了 `Into<Simd<T, N>>`。
assert_eq!(v + w, sum.into());
assert_eq!(v * w, prod.into());

具有整数元素的 Simd 将运算符视为环绕，就好像 T 是 Wrapping<T>。 因此，Simd 不实现 wrapping_add，因为这是默认行为。 这意味着即使在 “debug” 版本中也不会出现溢出警告。 对于大多数适合 Simd 的应用来说，换行就是 “not a bug”，甚至 “debug builds” 也不太可能容忍性能的损失。 如果需要，您可能需要考虑使用显式检查算法。 在整数上除以零仍然会导致 panic，因此如果无法接受，您可能需要考虑使用 f32 或 f64。

Layout

Simd<T, N> 的布局类似于 [T; N] (与 “shapes” 相同)，但对齐程度更高。 [T; N] 与 T 对齐，但 Simd<T, N> 将基于 T 和 N 进行对齐。 因此 transmute Simd<T, N> 到 [T; N] 并应优化为 “zero cost”，但反向转换可能需要编译器无法简单删除的副本。

ABI “Features”

由于 Rust 的安全保证，Simd<T, N> 目前通过内存传递和返回，而不是 SIMD 寄存器，除非作为优化。 建议在接受 Simd<T, N> 或返回它的函数上使用 #[inline]，但代价是代码生成时间，因为内联使用 SIMD 的函数可以省略大型函数序言或结尾，从而提高速度和代码大小。

future 中可能会更正对此的需求。

使用 #[inline(always)] 仍然需要格外小心。

带有不安全 Rust 的安全 SIMD

使用 Simd 的操作通常是安全的，但有很多理由希望将 SIMD 与 unsafe 代码结合使用。 必须注意尊重 Simd 和它可能被转换或派生的其他类型之间的差异。 特别是 Simd<T, N> 的布局可能类似于 [T; N]，并且可能允许一些变换，但对 [T; N] 的引用不能与对 Simd<T, N> 的引用互换。 因此，在使用 unsafe Rust 通过 raw pointers 读写 Simd<T, N> 时，最好先尝试使用 read_unaligned 和 write_unaligned。这是因为:

• read 和 write 需要完全对齐 (在这种情况下，Simd<T, N> 的对齐方式)
• Simd<T, N> 通常从 [T] 和其他与 T 对齐的类型读取或写入
• 组合这些操作违反了 unsafe 合同并将程序爆炸成一团未定义的行为
• 如果看到优化，编译器可以隐式调整布局以使未对齐的读取或写入完全对齐
• 如果 “unaligned” 变体在运行时对齐，大多数具有 “aligned” 和 “unaligned” 读写指令的现代处理器不会表现出性能差异

更少的义务意味着未对齐的读取和写入不太可能使程序不可靠，并且可能与更严格的替代方案一样快。 在尝试保证对齐时，[T]::as_simd 是将 [T] 转换为 [Simd<T, N>] 的一个选项，并允许在对齐的 SIMD 主体上进行良好的操作，但在处理标量头部和尾部时可能会花费更多时间。 如果这些还不够，最理想的是在使用 unsafe Rust 读写之前，将数据结构设计成已经对齐到 mem::align_of::<Simd<T, N>>()。 补偿这些事实的其他方法，如首先将 Simd 实体化到数组或从数组中实体化，由 Simd::from_array 和 Simd::from_slice 等安全方法处理。

Implementations

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

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

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

反转 vector 中 lanes 的顺序。

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

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

🔬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: Simd<T, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)

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

交错两个 vectors。

生成的 vectors 包含交替取自 self 和 other 的 lanes，首先填充第一个结果，然后填充第二个结果。

这个操作的反面是 Simd::deinterleave。

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

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

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

去交错两个 vectors。

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

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

这个操作的反面是 Simd::interleave。

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

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

pub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>

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

根据索引 vector 调配字节的 vector。 范围内的索引选择适当的字节。 指数 “out of bounds” 而不是选择 0.

请注意，当前实现是在标准库的构建期间选择的，因此可能需要 cargo build -Zbuild-std 才能解锁更好的性能，尤其是对于较大的 vectors。

计划中的编译器改进将支持使用 #[target_feature]。

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

pub const LANES: usize = N

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

此 vector 中的元素数。

pub const fn lanes(&self) -> usize

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

返回此 SIMD vector 中的元素数。

Examples

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

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

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

创建一个所有元素都设置为给定值的新 SIMD vector。

Examples

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

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

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

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

Examples

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

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

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

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

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

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

将数组转换为 SIMD vector。

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

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

将 SIMD vector 转换为数组。

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

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

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

Panics

如果切片的长度小于 vector 的 Simd::N，则会出现 panic。

Example

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

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

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

将 SIMD vector 写入切片的第一个 N 元素。

Panics

如果切片的长度小于 vector 的 Simd::N，则会出现 panic。

Example

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

pub fn cast<U>(self) -> Simd<U, N>where U: SimdCast, T: SimdCast,

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

将 SIMD vector 的元素按元素转换为另一个 SIMD 有效类型。

这遵循 Rust 的 as 转换的语义，用于在有符号和无符号之间转换整数 (将整数解释为 2s 补码，因此 -1 到 U::MAX 和 1 << (U::BITS -1) 成为 I::MIN )，以及从浮点数到整数 (截断或在极限处饱和) 每个元素。

Examples

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

// 形式上是等价的，但 `Simd::cast` 可以优化得更好。
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));

// 浮点转换不需要往返。
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));

pub fn cast_ptr<U>(self) -> Simd<U, N>where T: SimdCastPtr<U>, U: SimdElement,

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

将指针的 vector 转换为另一种指针类型。

pub unsafe fn to_int_unchecked<I>(self) -> Simd<I, N>where T: FloatToInt<I> + SimdCast, I: SimdCast,

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

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

Safety

该值必须：

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

如果这些要求不可行或代价高昂，请考虑使用安全函数 cast，它会在转换时饱和。

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

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

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

Examples

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);  // 注意越界的索引
let alt = Simd::from_array([-5, -4, -3, -2]);

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

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

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

从 slice 中的索引读取以构建 SIMD vector。 如果索引越界，则元素设置为 T: Default 给定的默认值。

Examples

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);  // 注意越界的索引

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

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

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

从 slice 中的索引读取以构建 SIMD vector。 掩码 启用 所有 true 索引并禁用所有 false 索引。 如果索引被禁用或越界，则从 or vector 中选择元素。

Examples

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // 包括越界索引
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // 包括一个屏蔽元素

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

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

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

从 slice 中的索引读取以构建 SIMD vector。 掩码 启用 所有 true 索引并禁用所有 false 索引。 如果禁用索引，则从 or vector 中选择元素。

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]); // 包括一个屏蔽元素
// 如果用这个掩码来收集，这是不合理的。让我们解决这个问题。
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

// 越界索引已被屏蔽，因此现在可以安全收集了。
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

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

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

从指针逐元素读取到 SIMD vector。

Safety

每次读取必须满足与 core::ptr::read 相同的条件。

Example

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

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

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

有条件地从指针逐元素读取到 SIMD vector。 掩码 启用 所有 true 指针并禁用所有 false 指针。 如果禁用指针，则从 or vector 中选择元素，并且不执行读取。

Safety

启用的元素必须满足与 core::ptr::read 相同的条件。

Example

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

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

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

将 SIMD vector 中的值写入 slice 中可能不连续的索引。 如果索引越界，则写入会被抑制而不会出现 panic。 如果分散的 vector 中的两个元素将写入同一索引，则只有最后一个元素才能保证实际写入。

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); // 两次逻辑写入意味着最后获胜。
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);

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

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

将值从 SIMD vector 写入 slice 中的多个可能不连续的索引。 掩码 启用 所有 true 索引并禁用所有 false 索引。 如果启用的索引越界，则写入会被抑制而不会出现 panic。 如果分散的 vector 中的两个启用元素将写入同一索引，则只有最后一个元素可以保证实际写入。

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]); // 包括一个屏蔽元素

vals.scatter_select(&mut vec, enable, idxs); // 最后一次写入被屏蔽，因此被省略。
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, N>, idxs: Simd<usize, N> )

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

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

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

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

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

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

按元素将指针写入 SIMD vector。

Safety

每次写入必须满足与 core::ptr::write 相同的条件。

Example

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

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

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

有条件地将指针逐元素写入 SIMD vector。 掩码 启用 所有 true 指针并禁用所有 false 指针。 如果禁用指针，则跳过对其指针的写入。

Safety

使能指针必须满足与 core::ptr::write 相同的条件。

Example

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

Trait Implementations

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

执行 + 操作。

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

type Output = Simd<f32, N>

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

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

执行 + 操作。

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

type Output = Simd<f64, N>

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

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

执行 + 操作。

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

type Output = Simd<i16, N>

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

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

执行 + 操作。

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

type Output = Simd<i32, N>

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

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

执行 + 操作。

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

type Output = Simd<i64, N>

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

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

执行 + 操作。

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

type Output = Simd<i8, N>

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

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

执行 + 操作。

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

type Output = Simd<isize, N>

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

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

执行 + 操作。

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

type Output = Simd<u16, N>

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

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

执行 + 操作。

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

type Output = Simd<u32, N>

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

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

执行 + 操作。

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

type Output = Simd<u64, N>

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

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

执行 + 操作。

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

type Output = Simd<u8, N>

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

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

执行 + 操作。

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

type Output = Simd<usize, N>

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

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

执行 + 操作。

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

fn add_assign(&mut self, rhs: U)

执行 += 操作。

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

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

将此类型转换为 (通常是推断的) 输入类型的错误引用。

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

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

将此类型转换为 (通常是推断的) 输入类型的错误引用。

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

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

将此类型转换为 (通常是推断的) 输入类型的共享引用。

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

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

将此类型转换为 (通常是推断的) 输入类型的共享引用。

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

执行 & 操作。

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

type Output = Simd<i16, N>

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

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

执行 & 操作。

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

type Output = Simd<i32, N>

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

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

执行 & 操作。

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

type Output = Simd<i64, N>

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

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

执行 & 操作。

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

type Output = Simd<i8, N>

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

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

执行 & 操作。

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

type Output = Simd<isize, N>

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

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

执行 & 操作。

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

type Output = Simd<u16, N>

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

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

执行 & 操作。

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

type Output = Simd<u32, N>

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

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

执行 & 操作。

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

type Output = Simd<u64, N>

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

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

执行 & 操作。

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

type Output = Simd<u8, N>

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

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

执行 & 操作。

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

type Output = Simd<usize, N>

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

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

执行 & 操作。

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

fn bitand_assign(&mut self, rhs: U)

执行 &= 操作。

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: &'rhs Simd<T, LANES> ) -> <&'lhs Simd<T, LANES> as BitOr<&'rhs Simd<T, LANES>>>::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> ) -> <Simd<T, LANES> as BitOr<&Simd<T, LANES>>>::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> ) -> <&Simd<T, LANES> as BitOr<Simd<T, LANES>>>::Output

执行 | 操作。

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

type Output = Simd<i16, N>

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

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

执行 | 操作。

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

type Output = Simd<i32, N>

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

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

执行 | 操作。

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

type Output = Simd<i64, N>

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

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

执行 | 操作。

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

type Output = Simd<i8, N>

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

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

执行 | 操作。

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

type Output = Simd<isize, N>

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

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

执行 | 操作。

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

type Output = Simd<u16, N>

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

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

执行 | 操作。

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

type Output = Simd<u32, N>

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

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

执行 | 操作。

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

type Output = Simd<u64, N>

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

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

执行 | 操作。

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

type Output = Simd<u8, N>

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

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

执行 | 操作。

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

type Output = Simd<usize, N>

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

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

执行 | 操作。

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

fn bitor_assign(&mut self, rhs: U)

执行 |= 操作。

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: &'rhs Simd<T, LANES> ) -> <&'lhs Simd<T, LANES> as BitXor<&'rhs Simd<T, LANES>>>::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> ) -> <Simd<T, LANES> as BitXor<&Simd<T, LANES>>>::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> ) -> <&Simd<T, LANES> as BitXor<Simd<T, LANES>>>::Output

执行 ^ 操作。

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

type Output = Simd<i16, N>

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

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

执行 ^ 操作。

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

type Output = Simd<i32, N>

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

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

执行 ^ 操作。

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

type Output = Simd<i64, N>

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

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

执行 ^ 操作。

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

type Output = Simd<i8, N>

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

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

执行 ^ 操作。

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

type Output = Simd<isize, N>

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

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

执行 ^ 操作。

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

type Output = Simd<u16, N>

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

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

执行 ^ 操作。

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

type Output = Simd<u32, N>

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

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

执行 ^ 操作。

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

type Output = Simd<u64, N>

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

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

执行 ^ 操作。

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

type Output = Simd<u8, N>

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

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

执行 ^ 操作。

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

type Output = Simd<usize, N>

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

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

执行 ^ 操作。

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

fn bitxor_assign(&mut self, rhs: U)

执行 ^= 操作。

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

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

返回值的副本。

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<(), Error>

Simd<T, N> 的调试格式类似于 [T] 的调试格式:

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

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

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

返回类型的 “默认值”。

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

执行 / 操作。

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

type Output = Simd<f32, N>

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

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

执行 / 操作。

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

type Output = Simd<f64, N>

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

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

执行 / 操作。

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

type Output = Simd<i16, N>

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

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

执行 / 操作。

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

type Output = Simd<i32, N>

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

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

执行 / 操作。

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

type Output = Simd<i64, N>

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

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

执行 / 操作。

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

type Output = Simd<i8, N>

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

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

执行 / 操作。

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

type Output = Simd<isize, N>

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

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

执行 / 操作。

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

type Output = Simd<u16, N>

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

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

执行 / 操作。

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

type Output = Simd<u32, N>

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

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

执行 / 操作。

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

type Output = Simd<u64, N>

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

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

执行 / 操作。

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

type Output = Simd<u8, N>

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

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

执行 / 操作。

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

type Output = Simd<usize, N>

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

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

执行 / 操作。

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

fn div_assign(&mut self, rhs: U)

执行 /= 操作。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

从输入类型转换为此类型。

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

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

将该值输入给定的 Hasher。

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, 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 as SliceIndex<[T]>>::Output

索引后返回的类型。

fn index(&self, index: I) -> &<Simd<T, LANES> as Index<I>>::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 <Simd<T, LANES> as Index<I>>::Output

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

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

执行 * 操作。

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

type Output = Simd<f32, N>

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

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

执行 * 操作。

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

type Output = Simd<f64, N>

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

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

执行 * 操作。

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

type Output = Simd<i16, N>

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

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

执行 * 操作。

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

type Output = Simd<i32, N>

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

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

执行 * 操作。

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

type Output = Simd<i64, N>

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

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

执行 * 操作。

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

type Output = Simd<i8, N>

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

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

执行 * 操作。

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

type Output = Simd<isize, N>

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

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

执行 * 操作。

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

type Output = Simd<u16, N>

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

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

执行 * 操作。

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

type Output = Simd<u32, N>

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

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

执行 * 操作。

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

type Output = Simd<u64, N>

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

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

执行 * 操作。

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

type Output = Simd<u8, N>

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

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

执行 * 操作。

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

type Output = Simd<usize, N>

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

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

执行 * 操作。

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

fn mul_assign(&mut self, rhs: U)

执行 *= 操作。

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

type Output = Simd<f32, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<f64, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<i16, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<i32, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<i64, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<i8, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<isize, LANES>

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

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

执行一元 - 运算。

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

type Output = Simd<i16, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<i32, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<i64, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<i8, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<isize, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<u16, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<u32, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<u64, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<u8, LANES>

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

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

执行一元 ! 操作。

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

type Output = Simd<usize, LANES>

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

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

执行一元 ! 操作。

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

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

此方法返回 self 和 other 之间的 Ordering。

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

比较并返回两个值中的最大值。

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

比较并返回两个值中的最小值。

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

将值限制在某个时间间隔内。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

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

fn partial_cmp(&self, other: &Simd<T, N>) -> 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>(iter: I) -> Simd<f32, LANES>where I: Iterator<Item = &'a Simd<f32, LANES>>,

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

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

该方法采用迭代器并通过乘以项从元素生成 Self。

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

执行 % 操作。

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

type Output = Simd<f32, N>

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

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

执行 % 操作。

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

type Output = Simd<f64, N>

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

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

执行 % 操作。

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

type Output = Simd<i16, N>

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

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

执行 % 操作。

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

type Output = Simd<i32, N>

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

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

执行 % 操作。

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

type Output = Simd<i64, N>

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

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

执行 % 操作。

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

type Output = Simd<i8, N>

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

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

执行 % 操作。

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

type Output = Simd<isize, N>

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

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

执行 % 操作。

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

type Output = Simd<u16, N>

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

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

执行 % 操作。

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

type Output = Simd<u32, N>

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

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

执行 % 操作。

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

type Output = Simd<u64, N>

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

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

执行 % 操作。

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

type Output = Simd<u8, N>

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

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

执行 % 操作。

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

type Output = Simd<usize, N>

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

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

执行 % 操作。

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

fn rem_assign(&mut self, rhs: U)

执行 %= 操作。

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: &'rhs Simd<T, LANES> ) -> <&'lhs Simd<T, LANES> as Shl<&'rhs Simd<T, LANES>>>::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> ) -> <Simd<T, LANES> as Shl<&Simd<T, LANES>>>::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> ) -> <&Simd<T, LANES> as Shl<Simd<T, LANES>>>::Output

执行 << 操作。

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

type Output = Simd<i16, N>

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

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

执行 << 操作。

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

type Output = Simd<i32, N>

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

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

执行 << 操作。

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

type Output = Simd<i64, N>

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

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

执行 << 操作。

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

type Output = Simd<i8, N>

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

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

执行 << 操作。

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

type Output = Simd<isize, N>

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

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

执行 << 操作。

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

type Output = Simd<u16, N>

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

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

执行 << 操作。

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

type Output = Simd<u32, N>

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

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

执行 << 操作。

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

type Output = Simd<u64, N>

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

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

执行 << 操作。

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

type Output = Simd<u8, N>

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

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

执行 << 操作。

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

type Output = Simd<usize, N>

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

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

执行 << 操作。

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

fn shl_assign(&mut self, rhs: U)

执行 <<= 操作。

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: &'rhs Simd<T, LANES> ) -> <&'lhs Simd<T, LANES> as Shr<&'rhs Simd<T, LANES>>>::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> ) -> <Simd<T, LANES> as Shr<&Simd<T, LANES>>>::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> ) -> <&Simd<T, LANES> as Shr<Simd<T, LANES>>>::Output

执行 >> 操作。

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

type Output = Simd<i16, N>

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

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

执行 >> 操作。

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

type Output = Simd<i32, N>

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

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

执行 >> 操作。

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

type Output = Simd<i64, N>

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

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

执行 >> 操作。

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

type Output = Simd<i8, N>

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

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

执行 >> 操作。

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

type Output = Simd<isize, N>

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

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

执行 >> 操作。

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

type Output = Simd<u16, N>

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

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

执行 >> 操作。

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

type Output = Simd<u32, N>

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

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

执行 >> 操作。

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

type Output = Simd<u64, N>

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

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

执行 >> 操作。

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

type Output = Simd<u8, N>

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

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

执行 >> 操作。

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

type Output = Simd<usize, N>

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

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

执行 >> 操作。

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

fn shr_assign(&mut self, rhs: U)

执行 >>= 操作。

impl<T, const LANES: usize> SimdConstPtr for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Usize = Simd<usize, LANES>

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

usize 的 Vector 与 lanes 的数量相同。

type Isize = Simd<isize, LANES>

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

isize 的 Vector 与 lanes 的数量相同。

type MutPtr = Simd<*mut T, LANES>

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

Vector 的可变指针指向同一类型。

type Mask = Mask<isize, LANES>

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

用于操作此 SIMD vector 类型的掩码类型。

fn is_null(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Mask

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

为每个为空的 lane 返回 true。

fn cast_mut(self) -> <Simd<*const T, LANES> as SimdConstPtr>::MutPtr

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

更改常量而不更改类型。

fn addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize

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

获取指针的 “address” 部分。

fn with_addr( self, addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>

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

使用给定地址创建一个新指针。

fn expose_addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize

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

获取指针的 “address” 部分，“exposes” 是 future 在 Self::from_exposed_addr 中使用的出处部分。

fn from_exposed_addr( addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>

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

将地址转换回指针，获取以前的 “exposed” 出处。

fn wrapping_offset( self, count: <Simd<*const T, LANES> as SimdConstPtr>::Isize ) -> Simd<*const T, LANES>

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

使用换行算法计算与指针的偏移量。

fn wrapping_add( self, count: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>

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

使用换行算法计算与指针的偏移量。

fn wrapping_sub( self, count: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>

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

使用换行算法计算与指针的偏移量。

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

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

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

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = f32

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

此 SIMD vector 类型包含的标量类型。

type Bits = Simd<u32, LANES>

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

此 SIMD vector 类型的位表示。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

返回每个 lane 的最小值。

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

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

返回每个 lane 的最大值。

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

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

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

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

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

返回 vector 的 lane 的总和。

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

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

减少乘。返回 vector 的 lanes 的乘积。

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

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

返回 vector 中的最大 lane。

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

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

返回 vector 中的最小 lane。

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

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

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

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = f64

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

此 SIMD vector 类型包含的标量类型。

type Bits = Simd<u64, LANES>

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

此 SIMD vector 类型的位表示。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

返回每个 lane 的最小值。

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

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

返回每个 lane 的最大值。

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

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

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

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

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

返回 vector 的 lane 的总和。

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

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

减少乘。返回 vector 的 lanes 的乘积。

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

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

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

impl<const LANES: usize> SimdInt for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = i16

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

fn saturating_abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

fn saturating_neg(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个正 lane 返回真，如果为零或负则返回假。

fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个负 lane 返回 true，如果为零或正则返回 false。

fn signum(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回代表每个 lane 符号的数字。

fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdInt for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = i32

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

fn saturating_abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

fn saturating_neg(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个正 lane 返回真，如果为零或负则返回假。

fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个负 lane 返回 true，如果为零或正则返回 false。

fn signum(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回代表每个 lane 符号的数字。

fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdInt for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = i64

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

fn saturating_abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

fn saturating_neg(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个正 lane 返回真，如果为零或负则返回假。

fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个负 lane 返回 true，如果为零或正则返回 false。

fn signum(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回代表每个 lane 符号的数字。

fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdInt for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = i8

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

fn saturating_abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

fn saturating_neg(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个正 lane 返回真，如果为零或负则返回假。

fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个负 lane 返回 true，如果为零或正则返回 false。

fn signum(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回代表每个 lane 符号的数字。

fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdInt for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

type Scalar = isize

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 绝对值，在 Rust 中实现。 每个 lane 都成为它的绝对值。

fn saturating_abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和绝对值，在 Rust 中实现。 作为 abs()，除了 MIN 值变为 MAX 而不是它本身。

fn saturating_neg(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和否定，在 Rust 中实现。 作为 neg()，除了 MIN 值变为 MAX 而不是它本身。

fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个正 lane 返回真，如果为零或负则返回假。

fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

对于每个负 lane 返回 true，如果为零或正则返回 false。

fn signum(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回代表每个 lane 符号的数字。

fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<T, const LANES: usize> SimdMutPtr for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Usize = Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

usize 的 Vector 与 lanes 的数量相同。

type Isize = Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

isize 的 Vector 与 lanes 的数量相同。

type ConstPtr = Simd<*const T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

常量指针的 Vector 指向同一类型。

type Mask = Mask<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

用于操作此 SIMD vector 类型的掩码类型。

fn is_null(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

为每个为空的 lane 返回 true。

fn cast_const(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::ConstPtr

🔬This is a nightly-only experimental API. (portable_simd #86656)

更改常量而不更改类型。

fn addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize

🔬This is a nightly-only experimental API. (portable_simd #86656)

获取指针的 “address” 部分。

fn with_addr( self, addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用给定地址创建一个新指针。

fn expose_addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize

🔬This is a nightly-only experimental API. (portable_simd #86656)

获取指针的 “address” 部分，“exposes” 是 future 在 Self::from_exposed_addr 中使用的出处部分。

fn from_exposed_addr( addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将地址转换回指针，获取以前的 “exposed” 出处。

fn wrapping_offset( self, count: <Simd<*mut T, LANES> as SimdMutPtr>::Isize ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用换行算法计算与指针的偏移量。

fn wrapping_add( self, count: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用换行算法计算与指针的偏移量。

fn wrapping_sub( self, count: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用换行算法计算与指针的偏移量。

impl<T, const LANES: usize> SimdOrd for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<*const T, LANES>) -> Simd<*const T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<*const T, LANES>) -> Simd<*const T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<*const T, LANES>, max: Simd<*const T, LANES> ) -> Simd<*const T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<T, const LANES: usize> SimdOrd for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<*mut T, LANES>) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<*mut T, LANES>) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<*mut T, LANES>, max: Simd<*mut T, LANES> ) -> Simd<*mut T, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<i16, LANES>, max: Simd<i16, LANES> ) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<i32, LANES>, max: Simd<i32, LANES> ) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<i64, LANES>, max: Simd<i64, LANES> ) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<i8, LANES>, max: Simd<i8, LANES> ) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<isize, LANES>, max: Simd<isize, LANES> ) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<u16, LANES>, max: Simd<u16, LANES> ) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<u32, LANES>, max: Simd<u32, LANES> ) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<u64, LANES>, max: Simd<u64, LANES> ) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<u8, LANES>, max: Simd<u8, LANES> ) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<const LANES: usize> SimdOrd for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最大值。

fn simd_min(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

使用 other 返回 lane 方向的最小值。

fn simd_clamp( self, min: Simd<usize, LANES>, max: Simd<usize, LANES> ) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

将每个 lane 限制在一定的间隔内。

impl<T, const LANES: usize> SimdPartialEq for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<T, const LANES: usize> SimdPartialEq for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<f32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<f64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<u16 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<u32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<u64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<u8 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialEq for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<<usize as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

每次比较返回的掩码类型。

fn simd_eq( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

fn simd_ne( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否等于 other 中对应的 lane。

impl<T, const LANES: usize> SimdPartialOrd for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<*const T, LANES> ) -> <Simd<*const T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<T, const LANES: usize> SimdPartialOrd for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<*mut T, LANES> ) -> <Simd<*mut T, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<f32, LANES> ) -> <Simd<f32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<i16, LANES> ) -> <Simd<i16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<i32, LANES> ) -> <Simd<i32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<i64, LANES> ) -> <Simd<i64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<i8, LANES> ) -> <Simd<i8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<isize, LANES> ) -> <Simd<isize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<u16, LANES> ) -> <Simd<u16, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<u32, LANES> ) -> <Simd<u32, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<u64, LANES> ) -> <Simd<u64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdPartialOrd for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于 other 中对应的 lane。

fn simd_le( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否小于或等于 other 中对应的 lane。

fn simd_gt( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于 other 中对应的 lane。

fn simd_ge( self, other: Simd<usize, LANES> ) -> <Simd<usize, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)

测试每个 lane 是否大于或等于 other 中对应的 lane。

impl<const LANES: usize> SimdUint for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Scalar = u16

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn reduce_sum(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<u16, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdUint for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Scalar = u32

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn reduce_sum(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<u32, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdUint for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Scalar = u64

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn reduce_sum(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<u64, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdUint for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Scalar = u8

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn reduce_sum(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const LANES: usize> SimdUint for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Scalar = usize

🔬This is a nightly-only experimental API. (portable_simd #86656)

此 SIMD vector 类型包含的标量类型。

fn saturating_add(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和加法。

fn saturating_sub(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)

Lanewise 饱和减法。

fn reduce_sum(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 总和，带包装加法。

fn reduce_product(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 的 lane 的乘积，带包装乘法。

fn reduce_max(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最大 lane。

fn reduce_min(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回 vector 中的最小 lane。

fn reduce_and(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位与。

fn reduce_or(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位或。

fn reduce_xor(self) -> <Simd<usize, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回跨 vector lane 的累积按位异或。

impl<const N: usize> StdFloat for Simd<f32, N>where LaneCount<N>: SupportedLaneCount,

fn fract(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回浮点的小数值，删除其整数部分。

fn mul_add(self, a: Self, b: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

融合乘法加法。 仅用一个舍入误差计算 (self * a) + b，比未融合的乘法加法产生更准确的结果。

fn sqrt(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

产生一个 vector，其中每个 lane 都具有 self 中等效索引 lane 的平方根值

fn ceil(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回大于或等于每个 lane 的最小整数。

fn floor(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回小于或等于每个 lane 的最大整数值。

fn round(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

舍入到最接近的整数值。接近于零。

fn trunc(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回浮点的整数值，去掉小数部分。

impl<const N: usize> StdFloat for Simd<f64, N>where LaneCount<N>: SupportedLaneCount,

fn fract(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回浮点的小数值，删除其整数部分。

fn mul_add(self, a: Self, b: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

融合乘法加法。 仅用一个舍入误差计算 (self * a) + b，比未融合的乘法加法产生更准确的结果。

fn sqrt(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

产生一个 vector，其中每个 lane 都具有 self 中等效索引 lane 的平方根值

fn ceil(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回大于或等于每个 lane 的最小整数。

fn floor(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回小于或等于每个 lane 的最大整数值。

fn round(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

舍入到最接近的整数值。接近于零。

fn trunc(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd #86656)

返回浮点的整数值，去掉小数部分。

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: &'rhs Simd<T, LANES> ) -> <&'lhs Simd<T, LANES> as Sub<&'rhs Simd<T, LANES>>>::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> ) -> <Simd<T, LANES> as Sub<&Simd<T, LANES>>>::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> ) -> <&Simd<T, LANES> as Sub<Simd<T, LANES>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<f32, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<f32, N>) -> <Simd<f32, N> as Sub<Simd<f32, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<f64, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<f64, N>) -> <Simd<f64, N> as Sub<Simd<f64, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i16, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<i16, N>) -> <Simd<i16, N> as Sub<Simd<i16, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i32, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<i32, N>) -> <Simd<i32, N> as Sub<Simd<i32, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i64, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<i64, N>) -> <Simd<i64, N> as Sub<Simd<i64, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<i8, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<i8, N>) -> <Simd<i8, N> as Sub<Simd<i8, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<isize, N>

应用 - 运算符后的结果类型。

fn sub( self, rhs: Simd<isize, N> ) -> <Simd<isize, N> as Sub<Simd<isize, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u16, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<u16, N>) -> <Simd<u16, N> as Sub<Simd<u16, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u32, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<u32, N>) -> <Simd<u32, N> as Sub<Simd<u32, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u64, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<u64, N>) -> <Simd<u64, N> as Sub<Simd<u64, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<u8, N>

应用 - 运算符后的结果类型。

fn sub(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Sub<Simd<u8, N>>>::Output

执行 - 操作。

impl<const N: usize> Sub<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

type Output = Simd<usize, N>

应用 - 运算符后的结果类型。

fn sub( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Sub<Simd<usize, N>>>::Output

执行 - 操作。

impl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Sub<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

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>(iter: I) -> Simd<f32, LANES>where I: Iterator<Item = &'a Simd<f32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<f64, LANES>where I: Iterator<Item = &'a Simd<f64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i16, LANES>where I: Iterator<Item = &'a Simd<i16, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<i32, LANES>> for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i32, LANES>where I: Iterator<Item = &'a Simd<i32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<i64, LANES>> for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i64, LANES>where I: Iterator<Item = &'a Simd<i64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<i8, LANES>> for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i8, LANES>where I: Iterator<Item = &'a Simd<i8, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<isize, LANES>> for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<isize, LANES>where I: Iterator<Item = &'a Simd<isize, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<u16, LANES>> for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u16, LANES>where I: Iterator<Item = &'a Simd<u16, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<u32, LANES>> for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u32, LANES>where I: Iterator<Item = &'a Simd<u32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<u64, LANES>> for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u64, LANES>where I: Iterator<Item = &'a Simd<u64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = &'a Simd<u8, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<'a, const LANES: usize> Sum<&'a Simd<usize, LANES>> for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<usize, LANES>where I: Iterator<Item = &'a Simd<usize, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<f32, LANES>> for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<f32, LANES>where I: Iterator<Item = Simd<f32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<f64, LANES>where I: Iterator<Item = Simd<f64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i16, LANES>where I: Iterator<Item = Simd<i16, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<i32, LANES>> for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i32, LANES>where I: Iterator<Item = Simd<i32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<i64, LANES>> for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i64, LANES>where I: Iterator<Item = Simd<i64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<i8, LANES>> for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<i8, LANES>where I: Iterator<Item = Simd<i8, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<isize, LANES>> for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<isize, LANES>where I: Iterator<Item = Simd<isize, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<u16, LANES>> for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u16, LANES>where I: Iterator<Item = Simd<u16, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<u32, LANES>> for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u32, LANES>where I: Iterator<Item = Simd<u32, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<u64, LANES>> for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u64, LANES>where I: Iterator<Item = Simd<u64, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = Simd<u8, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<const LANES: usize> Sum<Simd<usize, LANES>> for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn sum<I>(iter: I) -> Simd<usize, LANES>where I: Iterator<Item = Simd<usize, LANES>>,

使用迭代器并通过 “summing up” 项从元素生成 Self 的方法。

impl<T, const N: usize> TryFrom<&[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

type Error = TryFromSliceError

发生转换错误时返回的类型。

fn try_from(slice: &[T]) -> Result<Simd<T, N>, TryFromSliceError>

执行转换。

impl<T, const N: usize> TryFrom<&mut [T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

type Error = TryFromSliceError

发生转换错误时返回的类型。

fn try_from(slice: &mut [T]) -> Result<Simd<T, N>, TryFromSliceError>

执行转换。

impl<T, const N: usize> Copy for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

impl<T, const N: usize> Eq for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Eq,