Struct std::simd::Simd

source ·
#[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)
Expand description

具有 [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());
Run

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

Layout

Simd<T, N> 的布局类似于 [T; N] (与 “shapes” 相同),但对齐程度更高。 [T; N]T 对齐,但 Simd<T, N> 将基于 TN 进行对齐。 因此 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_unalignedwrite_unaligned。这是因为:

  • readwrite 需要完全对齐 (在这种情况下,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_arraySimd::from_slice 等安全方法处理。

Implementations§

source§

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

source

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

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

反转 vector 中 lanes 的顺序。

source

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 中的第一个元素。

source

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 的元素将成为切片中的第一个元素。

source

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

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

交错两个 vectors。

生成的 vectors 包含交替取自 selfother 的 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]);
Run
source

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

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

去交错两个 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]);
Run
source§

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

source

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]

source§

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

source

pub const LANES: usize = N

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

此 vector 中的元素数。

source

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

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

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

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

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

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

source

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

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

将数组转换为 SIMD vector。

source

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

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

将 SIMD vector 转换为数组。

source

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

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

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 补码,因此 -1U::MAX1 << (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]));
Run
source

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 转换为另一种指针类型。

source

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,它会在转换时饱和。

source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

从指针逐元素读取到 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]));
Run
source

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

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

有条件地从指针逐元素读取到 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]));
Run
source

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

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

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

将值从 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]);
Run
source

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

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

将值从 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]);
Run
source

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

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

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

有条件地将指针逐元素写入 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]);
Run

Trait Implementations§

source§

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

§

type Output = Simd<T, LANES>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<f32, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<f64, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 + 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 + 操作。 Read more
source§

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

source§

fn add_assign(&mut self, rhs: U)

执行 += 操作。 Read more
source§

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

§

type Output = Simd<T, LANES>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 & 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 & 操作。 Read more
source§

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

source§

fn bitand_assign(&mut self, rhs: U)

执行 &= 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 | 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 | 操作。 Read more
source§

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

source§

fn bitor_assign(&mut self, rhs: U)

执行 |= 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 ^ 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 ^ 操作。 Read more
source§

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

source§

fn bitxor_assign(&mut self, rhs: U)

执行 ^= 操作。 Read more
source§

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

source§

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

返回值的副本。 Read more
1.0.0 · source§

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

source 执行复制分配。 Read more
source§

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

source§

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

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

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

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

source§

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

返回类型的 “默认值”。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<f32, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<f64, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 / 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 / 操作。 Read more
source§

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

source§

fn div_assign(&mut self, rhs: U)

执行 /= 操作。 Read more
source§

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

将该值输入给定的 HasherRead more
1.3.0 · source§

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

将这种类型的切片送入给定的 Hasher 中。 Read more
source§

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

§

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

索引后返回的类型。
source§

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

执行索引 (container[index]) 操作。 Read more
source§

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

source§

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

执行可变索引 (container[index]) 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<f32, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<f64, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 * 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 * 操作。 Read more
source§

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

source§

fn mul_assign(&mut self, rhs: U)

执行 *= 操作。 Read more
source§

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

§

type Output = Simd<f32, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<f64, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<i16, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<i32, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<i64, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<i8, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<isize, LANES>

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

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

执行一元 - 运算。 Read more
source§

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

§

type Output = Simd<i16, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<i32, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<i64, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<i8, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<isize, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<u16, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<u32, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<u64, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<u8, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

§

type Output = Simd<usize, LANES>

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

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

执行一元 ! 操作。 Read more
source§

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

source§

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

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

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

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

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

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

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

将值限制在某个时间间隔内。 Read more
source§

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

source§

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

此方法测试 selfother 值是否相等,并由 == 使用。
source§

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

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

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

source§

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

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
1.0.0 · source§

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

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
1.0.0 · source§

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

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
1.0.0 · source§

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

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
1.0.0 · source§

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

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
source§

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

§

type Output = Simd<T, LANES>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<f32, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<f64, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 % 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 % 操作。 Read more
source§

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

source§

fn rem_assign(&mut self, rhs: U)

执行 %= 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<u32, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<u64, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<u8, N>

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

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

执行 << 操作。 Read more
source§

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

§

type Output = Simd<usize, N>

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

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

执行 << 操作。 Read more
source§

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

source§

fn shl_assign(&mut self, rhs: U)

执行 <<= 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<T, LANES>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<i16, N>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<i32, N>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<i64, N>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<i8, N>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<isize, N>

应用 >> 运算符后的结果类型。
source§

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

执行 >> 操作。 Read more
source§

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

§

type Output = Simd<u16, N>

应用 >> 运算符后的结果类型。
source§

fn shr(self, rhs: Simd<u16, N>) -> <Simd<u16, N> as Shr<Simd<u16, N>>>::Output

执行 >> 操作。 Read more
source§

impl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u32, N>

应用 >> 运算符后的结果类型。
source§

fn shr(self, rhs: Simd<u32, N>) -> <Simd<u32, N> as Shr<Simd<u32, N>>>::Output

执行 >> 操作。 Read more
source§

impl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u64, N>

应用 >> 运算符后的结果类型。
source§

fn shr(self, rhs: Simd<u64, N>) -> <Simd<u64, N> as Shr<Simd<u64, N>>>::Output

执行 >> 操作。 Read more
source§

impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<u8, N>

应用 >> 运算符后的结果类型。
source§

fn shr(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Shr<Simd<u8, N>>>::Output

执行 >> 操作。 Read more
source§

impl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,

§

type Output = Simd<usize, N>

应用 >> 运算符后的结果类型。
source§

fn shr( self, rhs: Simd<usize, N> ) -> <Simd<usize, N> as Shr<Simd<usize, N>>>::Output

执行 >> 操作。 Read more
source§

impl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Shr<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

fn shr_assign(&mut self, rhs: U)

执行 >>= 操作。 Read more
source§

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 类型的掩码类型。
source§

fn is_null(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
为每个为空的 lane 返回 true
source§

fn cast_mut(self) -> <Simd<*const T, LANES> as SimdConstPtr>::MutPtr

🔬This is a nightly-only experimental API. (portable_simd #86656)
更改常量而不更改类型。 Read more
source§

fn addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize

🔬This is a nightly-only experimental API. (portable_simd #86656)
获取指针的 “address” 部分。 Read more
source§

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)
使用给定地址创建一个新指针。 Read more
source§

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 中使用的出处部分。
source§

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” 出处。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

impl<const LANES: usize> SimdFloat for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #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 类型的位表示。
source§

fn to_bits(self) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
原始转换为无符号整数 vector 类型,其大小和数量与 lanes 相同。
source§

fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
来自具有相同大小和数量的 lanes 的无符号整数 vector 类型的原始变换。
source§

fn abs(self) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
生成一个 vector,其中每个 lane 都具有 self 中等效索引 lane 的绝对值。
source§

fn recip(self) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
获取每个 lane 的倒数 (inverse),1/x
source§

fn to_degrees(self) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 从弧度转换为度数。
source§

fn to_radians(self) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 从度数转换为弧度。
source§

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 和正无穷大。
source§

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 和负无穷大。
source§

fn is_nan(self) -> <Simd<f32, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值为 NaN,则为每个 lane 返回 true。
source§

fn is_infinite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值是正无穷大或负无穷大,则为每个 lane 返回 true。
source§

fn is_finite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值既不是无穷大也不是 NaN,则为每个 lane 返回 true。
source§

fn is_subnormal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值为 subnormal,则为每个 lane 返回 true。
source§

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。
source§

fn signum(self) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用代表其符号的数字替换每个 lane。 Read more
source§

fn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
self 的大小和 sign 的符号返回每个 lane。 Read more
source§

fn simd_min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回每个 lane 的最小值。 Read more
source§

fn simd_max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回每个 lane 的最大值。 Read more
source§

fn simd_clamp( self, min: Simd<f32, LANES>, max: Simd<f32, LANES> ) -> Simd<f32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的区间内,除非它是 NaN。 Read more
source§

fn reduce_sum(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的总和。 Read more
source§

fn reduce_product(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
减少乘。返回 vector 的 lanes 的乘积。 Read more
source§

fn reduce_max(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 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 类型的位表示。
source§

fn to_bits(self) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
原始转换为无符号整数 vector 类型,其大小和数量与 lanes 相同。
source§

fn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
来自具有相同大小和数量的 lanes 的无符号整数 vector 类型的原始变换。
source§

fn abs(self) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
生成一个 vector,其中每个 lane 都具有 self 中等效索引 lane 的绝对值。
source§

fn recip(self) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
获取每个 lane 的倒数 (inverse),1/x
source§

fn to_degrees(self) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 从弧度转换为度数。
source§

fn to_radians(self) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 从度数转换为弧度。
source§

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 和正无穷大。
source§

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 和负无穷大。
source§

fn is_nan(self) -> <Simd<f64, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值为 NaN,则为每个 lane 返回 true。
source§

fn is_infinite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值是正无穷大或负无穷大,则为每个 lane 返回 true。
source§

fn is_finite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值既不是无穷大也不是 NaN,则为每个 lane 返回 true。
source§

fn is_subnormal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
如果每个 lane 的值为 subnormal,则为每个 lane 返回 true。
source§

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。
source§

fn signum(self) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用代表其符号的数字替换每个 lane。 Read more
source§

fn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
self 的大小和 sign 的符号返回每个 lane。 Read more
source§

fn simd_min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回每个 lane 的最小值。 Read more
source§

fn simd_max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回每个 lane 的最大值。 Read more
source§

fn simd_clamp( self, min: Simd<f64, LANES>, max: Simd<f64, LANES> ) -> Simd<f64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的区间内,除非它是 NaN。 Read more
source§

fn reduce_sum(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的总和。 Read more
source§

fn reduce_product(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
减少乘。返回 vector 的 lanes 的乘积。 Read more
source§

fn reduce_max(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

impl<const LANES: usize> SimdInt for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 SIMD vector 类型的掩码类型。
§

type Scalar = i16

🔬This is a nightly-only experimental API. (portable_simd #86656)
此 SIMD vector 类型包含的标量类型。
source§

fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和加法。 Read more
source§

fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和减法。 Read more
source§

fn abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 绝对值,在 Rust 中实现。 每个 lane 都成为它的绝对值。 Read more
source§

fn saturating_abs(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和绝对值,在 Rust 中实现。 作为 abs(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn saturating_neg(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和否定,在 Rust 中实现。 作为 neg(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个正 lane 返回真,如果为零或负则返回假。
source§

fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个负 lane 返回 true,如果为零或正则返回 false。
source§

fn signum(self) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回代表每个 lane 符号的数字。 Read more
source§

fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 总和,带包装加法。 Read more
source§

fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的乘积,带包装乘法。 Read more
source§

fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位与。
source§

fn reduce_or(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位或。
source§

fn reduce_xor(self) -> <Simd<i16, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位异或。
source§

impl<const LANES: usize> SimdInt for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 SIMD vector 类型的掩码类型。
§

type Scalar = i32

🔬This is a nightly-only experimental API. (portable_simd #86656)
此 SIMD vector 类型包含的标量类型。
source§

fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和加法。 Read more
source§

fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和减法。 Read more
source§

fn abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 绝对值,在 Rust 中实现。 每个 lane 都成为它的绝对值。 Read more
source§

fn saturating_abs(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和绝对值,在 Rust 中实现。 作为 abs(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn saturating_neg(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和否定,在 Rust 中实现。 作为 neg(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个正 lane 返回真,如果为零或负则返回假。
source§

fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个负 lane 返回 true,如果为零或正则返回 false。
source§

fn signum(self) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回代表每个 lane 符号的数字。 Read more
source§

fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 总和,带包装加法。 Read more
source§

fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的乘积,带包装乘法。 Read more
source§

fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位与。
source§

fn reduce_or(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位或。
source§

fn reduce_xor(self) -> <Simd<i32, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位异或。
source§

impl<const LANES: usize> SimdInt for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 SIMD vector 类型的掩码类型。
§

type Scalar = i64

🔬This is a nightly-only experimental API. (portable_simd #86656)
此 SIMD vector 类型包含的标量类型。
source§

fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和加法。 Read more
source§

fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和减法。 Read more
source§

fn abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 绝对值,在 Rust 中实现。 每个 lane 都成为它的绝对值。 Read more
source§

fn saturating_abs(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和绝对值,在 Rust 中实现。 作为 abs(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn saturating_neg(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和否定,在 Rust 中实现。 作为 neg(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个正 lane 返回真,如果为零或负则返回假。
source§

fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个负 lane 返回 true,如果为零或正则返回 false。
source§

fn signum(self) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回代表每个 lane 符号的数字。 Read more
source§

fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 总和,带包装加法。 Read more
source§

fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的乘积,带包装乘法。 Read more
source§

fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位与。
source§

fn reduce_or(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位或。
source§

fn reduce_xor(self) -> <Simd<i64, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位异或。
source§

impl<const LANES: usize> SimdInt for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 SIMD vector 类型的掩码类型。
§

type Scalar = i8

🔬This is a nightly-only experimental API. (portable_simd #86656)
此 SIMD vector 类型包含的标量类型。
source§

fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和加法。 Read more
source§

fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和减法。 Read more
source§

fn abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 绝对值,在 Rust 中实现。 每个 lane 都成为它的绝对值。 Read more
source§

fn saturating_abs(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和绝对值,在 Rust 中实现。 作为 abs(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn saturating_neg(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和否定,在 Rust 中实现。 作为 neg(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个正 lane 返回真,如果为零或负则返回假。
source§

fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个负 lane 返回 true,如果为零或正则返回 false。
source§

fn signum(self) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回代表每个 lane 符号的数字。 Read more
source§

fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 总和,带包装加法。 Read more
source§

fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的乘积,带包装乘法。 Read more
source§

fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位与。
source§

fn reduce_or(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位或。
source§

fn reduce_xor(self) -> <Simd<i8, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位异或。
source§

impl<const LANES: usize> SimdInt for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
用于操作此 SIMD vector 类型的掩码类型。
§

type Scalar = isize

🔬This is a nightly-only experimental API. (portable_simd #86656)
此 SIMD vector 类型包含的标量类型。
source§

fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和加法。 Read more
source§

fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和减法。 Read more
source§

fn abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 绝对值,在 Rust 中实现。 每个 lane 都成为它的绝对值。 Read more
source§

fn saturating_abs(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和绝对值,在 Rust 中实现。 作为 abs(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn saturating_neg(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
Lanewise 饱和否定,在 Rust 中实现。 作为 neg(),除了 MIN 值变为 MAX 而不是它本身。 Read more
source§

fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个正 lane 返回真,如果为零或负则返回假。
source§

fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
对于每个负 lane 返回 true,如果为零或正则返回 false。
source§

fn signum(self) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回代表每个 lane 符号的数字。 Read more
source§

fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 总和,带包装加法。 Read more
source§

fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 的 lane 的乘积,带包装乘法。 Read more
source§

fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最大 lane。 Read more
source§

fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回 vector 中的最小 lane。 Read more
source§

fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位与。
source§

fn reduce_or(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位或。
source§

fn reduce_xor(self) -> <Simd<isize, LANES> as SimdInt>::Scalar

🔬This is a nightly-only experimental API. (portable_simd #86656)
返回跨 vector lane 的累积按位异或。
source§

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 类型的掩码类型。
source§

fn is_null(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
为每个为空的 lane 返回 true
source§

fn cast_const(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::ConstPtr

🔬This is a nightly-only experimental API. (portable_simd #86656)
更改常量而不更改类型。 Read more
source§

fn addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize

🔬This is a nightly-only experimental API. (portable_simd #86656)
获取指针的 “address” 部分。 Read more
source§

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)
使用给定地址创建一个新指针。 Read more
source§

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 中使用的出处部分。
source§

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” 出处。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

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)
使用换行算法计算与指针的偏移量。 Read more
source§

impl<T, const LANES: usize> SimdOrd for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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 方向的最大值。
source§

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 方向的最小值。
source§

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 限制在一定的间隔内。 Read more
source§

impl<T, const LANES: usize> SimdOrd for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

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 方向的最大值。
source§

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 方向的最小值。
source§

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 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<i16, LANES>, max: Simd<i16, LANES> ) -> Simd<i16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<i32, LANES>, max: Simd<i32, LANES> ) -> Simd<i32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<i64, LANES>, max: Simd<i64, LANES> ) -> Simd<i64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<i8, LANES>, max: Simd<i8, LANES> ) -> Simd<i8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<isize, LANES>, max: Simd<isize, LANES> ) -> Simd<isize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<u16, LANES>, max: Simd<u16, LANES> ) -> Simd<u16, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<u32, LANES>, max: Simd<u32, LANES> ) -> Simd<u32, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<u64, LANES>, max: Simd<u64, LANES> ) -> Simd<u64, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<u8, LANES>, max: Simd<u8, LANES> ) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

impl<const LANES: usize> SimdOrd for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

fn simd_max(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最大值。
source§

fn simd_min(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
使用 other 返回 lane 方向的最小值。
source§

fn simd_clamp( self, min: Simd<usize, LANES>, max: Simd<usize, LANES> ) -> Simd<usize, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
将每个 lane 限制在一定的间隔内。 Read more
source§

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)
每次比较返回的掩码类型。
source§

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。
source§

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。
source§

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)
每次比较返回的掩码类型。
source§

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。
source§

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。
source§

impl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<f32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
每次比较返回的掩码类型。
source§

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。
source§

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。
source§

impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<f64 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
每次比较返回的掩码类型。
source§

fn simd_eq( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
测试每个 lane 是否等于 other 中对应的 lane。
source§

fn simd_ne( self, other: Simd<f64, LANES> ) -> <Simd<f64, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (portable_simd #86656)
测试每个 lane 是否等于 other 中对应的 lane。
source§

impl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
每次比较返回的掩码类型。
source§

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。
source§

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。
source§

impl<const LANES: usize> SimdPartialEq for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (portable_simd #86656)
每次比较返回的掩码类型。
source