#[repr(simd)]pub struct Simd<T, const N: usize>(_)
where
LaneCount<N>: SupportedLaneCount,
T: SimdElement;
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
将运算符视为环绕,就好像 T
是 Wrapping<T>
。
因此,Simd
不实现 wrapping_add
,因为这是默认行为。
这意味着即使在 “debug” 版本中也不会出现溢出警告。
对于大多数适合 Simd
的应用来说,换行就是 “not a bug”,甚至 “debug builds” 也不太可能容忍性能的损失。
如果需要,您可能需要考虑使用显式检查算法。
在整数上除以零仍然会导致 panic,因此如果无法接受,您可能需要考虑使用 f32
或 f64
。
Layout
Simd<T, N>
的布局类似于 [T; N]
(与 “shapes” 相同),但对齐程度更高。
[T; N]
与 T
对齐,但 Simd<T, N>
将基于 T
和 N
进行对齐。
因此 transmute
Simd<T, N>
到 [T; N]
并应优化为 “zero cost”,但反向转换可能需要编译器无法简单删除的副本。
ABI “Features”
由于 Rust 的安全保证,Simd<T, N>
目前通过内存传递和返回,而不是 SIMD 寄存器,除非作为优化。
建议在接受 Simd<T, N>
或返回它的函数上使用 #[inline]
,但代价是代码生成时间,因为内联使用 SIMD 的函数可以省略大型函数序言或结尾,从而提高速度和代码大小。
future 中可能会更正对此的需求。
使用 #[inline(always)]
仍然需要格外小心。
带有不安全 Rust 的安全 SIMD
使用 Simd
的操作通常是安全的,但有很多理由希望将 SIMD 与 unsafe
代码结合使用。
必须注意尊重 Simd
和它可能被转换或派生的其他类型之间的差异。
特别是 Simd<T, N>
的布局可能类似于 [T; N]
,并且可能允许一些变换,但对 [T; N]
的引用不能与对 Simd<T, N>
的引用互换。
因此,在使用 unsafe
Rust 通过 raw pointers 读写 Simd<T, N>
时,最好先尝试使用 read_unaligned
和 write_unaligned
。这是因为:
read
和write
需要完全对齐 (在这种情况下,Simd<T, N>
的对齐方式)Simd<T, N>
通常从[T]
和其他与T
对齐的类型读取或写入- 组合这些操作违反了
unsafe
合同并将程序爆炸成一团未定义的行为 - 如果看到优化,编译器可以隐式调整布局以使未对齐的读取或写入完全对齐
- 如果 “unaligned” 变体在运行时对齐,大多数具有 “aligned” 和 “unaligned” 读写指令的现代处理器不会表现出性能差异
更少的义务意味着未对齐的读取和写入不太可能使程序不可靠,并且可能与更严格的替代方案一样快。
在尝试保证对齐时,[T]::as_simd
是将 [T]
转换为 [Simd<T, N>]
的一个选项,并允许在对齐的 SIMD 主体上进行良好的操作,但在处理标量头部和尾部时可能会花费更多时间。
如果这些还不够,最理想的是在使用 unsafe
Rust 读写之前,将数据结构设计成已经对齐到 mem::align_of::<Simd<T, N>>()
。
补偿这些事实的其他方法,如首先将 Simd
实体化到数组或从数组中实体化,由 Simd::from_array
和 Simd::from_slice
等安全方法处理。
Implementations§
source§impl<T, const LANES: usize> Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount,
sourcepub fn reverse(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn reverse(self) -> Simd<T, LANES>
portable_simd
#86656)反转 vector 中 lanes 的顺序。
sourcepub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>
portable_simd
#86656)旋转 vector,使切片的第一个 OFFSET
元素移动到末尾,而最后一个 LANES - OFFSET
元素移动到前面。
调用 rotate_lanes_left
后,先前在 OFFSET
lane 中的元素将成为该 lane 中的第一个元素。
sourcepub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>
portable_simd
#86656)旋转 vector,使 vector 的第一个 LANES - OFFSET
元素移动到末尾,而最后一个 OFFSET
元素移动到前面。
调用 rotate_lanes_right
后,之前位于索引 LANES - OFFSET
的元素将成为切片中的第一个元素。
sourcepub fn interleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn interleave( self, other: Simd<T, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)
portable_simd
#86656)交错两个 vectors。
生成的 vectors 包含交替取自 self
和 other
的 lanes,首先填充第一个结果,然后填充第二个结果。
这个操作的反面是 Simd::deinterleave
。
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);
Runsourcepub fn deinterleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn deinterleave( self, other: Simd<T, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)
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]);
Runsource§impl<const N: usize> Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Simd<u8, N>where LaneCount<N>: SupportedLaneCount,
sourcepub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>
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,
impl<T, const N: usize> Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
sourcepub const LANES: usize = N
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const LANES: usize = N
portable_simd
#86656)此 vector 中的元素数。
sourcepub const fn lanes(&self) -> usize
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn lanes(&self) -> usize
portable_simd
#86656)sourcepub fn splat(value: T) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn splat(value: T) -> Simd<T, N>
portable_simd
#86656)sourcepub const fn as_array(&self) -> &[T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn as_array(&self) -> &[T; N]
portable_simd
#86656)sourcepub fn as_mut_array(&mut self) -> &mut [T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn as_mut_array(&mut self) -> &mut [T; N]
portable_simd
#86656)返回一个包含整个 SIMD vector 的可变数组引用。
sourcepub const fn from_array(array: [T; N]) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_array(array: [T; N]) -> Simd<T, N>
portable_simd
#86656)将数组转换为 SIMD vector。
sourcepub const fn to_array(self) -> [T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn to_array(self) -> [T; N]
portable_simd
#86656)将 SIMD vector 转换为数组。
sourcepub const fn from_slice(slice: &[T]) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_slice(slice: &[T]) -> Simd<T, N>
portable_simd
#86656)sourcepub fn copy_to_slice(self, slice: &mut [T])
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn copy_to_slice(self, slice: &mut [T])
portable_simd
#86656)sourcepub fn cast<U>(self) -> Simd<U, N>where
U: SimdCast,
T: SimdCast,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn cast<U>(self) -> Simd<U, N>where U: SimdCast, T: SimdCast,
portable_simd
#86656)将 SIMD vector 的元素按元素转换为另一个 SIMD 有效类型。
这遵循 Rust 的 as
转换的语义,用于在有符号和无符号之间转换整数 (将整数解释为 2s 补码,因此 -1
到 U::MAX
和 1 << (U::BITS -1)
成为 I::MIN
),以及从浮点数到整数 (截断或在极限处饱和) 每个元素。
Examples
let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);
let ints = floats.cast::<i32>();
assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));
// 形式上是等价的,但 `Simd::cast` 可以优化得更好。
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));
// 浮点转换不需要往返。
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));
Runsourcepub fn cast_ptr<U>(self) -> Simd<U, N>where
T: SimdCastPtr<U>,
U: SimdElement,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn cast_ptr<U>(self) -> Simd<U, N>where T: SimdCastPtr<U>, U: SimdElement,
portable_simd
#86656)将指针的 vector 转换为另一种指针类型。
sourcepub 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)
pub unsafe fn to_int_unchecked<I>(self) -> Simd<I, N>where T: FloatToInt<I> + SimdCast, I: SimdCast,
portable_simd
#86656)sourcepub 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)
pub fn gather_or( slice: &[T], idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
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]));
Runsourcepub 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)
pub fn gather_or_default(slice: &[T], idxs: Simd<usize, N>) -> Simd<T, N>where T: Default,
portable_simd
#86656)sourcepub 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)
pub fn gather_select( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
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]));
Runsourcepub 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)
pub unsafe fn gather_select_unchecked( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
portable_simd
#86656)从 slice
中的索引读取以构建 SIMD vector。
掩码 启用
所有 true
索引并禁用所有 false
索引。
如果禁用索引,则从 or
vector 中选择元素。
Safety
使用 enable
d 越界索引调用这个函数是 未定义的行为,即使结果值没有被使用。
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]));
Runsourcepub 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)
pub unsafe fn gather_ptr(source: Simd<*const T, N>) -> Simd<T, N>where T: Default,
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]));
Runsourcepub 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)
pub unsafe fn gather_select_ptr( source: Simd<*const T, N>, enable: Mask<isize, N>, or: Simd<T, N> ) -> Simd<T, N>
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]));
Runsourcepub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)
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]);
Runsourcepub 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)
pub fn scatter_select( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )
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]);
Runsourcepub 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)
pub unsafe fn scatter_select_unchecked( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )
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]);
Runsourcepub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)
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]);
Runsourcepub 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)
pub unsafe fn scatter_select_ptr( self, dest: Simd<*mut T, N>, enable: Mask<isize, N> )
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]);
RunTrait 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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Add<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Add<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn add_assign(&mut self, rhs: U)
+=
操作。 Read moresource§impl<T, const N: usize> AsMut<[T]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsMut<[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const N: usize> AsRef<[T]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsRef<[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
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,
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,
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,
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,
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,
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,
source§impl<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn bitand_assign(&mut self, rhs: U)
&=
操作。 Read moresource§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,
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,
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,
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,
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,
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,
source§impl<const N: usize> BitOr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitOr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn bitor_assign(&mut self, rhs: U)
|=
操作。 Read moresource§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,
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,
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,
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,
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,
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,
source§impl<const N: usize> BitXor<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> BitXor<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn bitxor_assign(&mut self, rhs: U)
^=
操作。 Read moresource§impl<T, const N: usize> Clone for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> Clone for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const LANES: usize> Debug for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Debug,
impl<T, const LANES: usize> Debug for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Debug,
source§impl<T, const N: usize> Default for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement + Default,
impl<T, const N: usize> Default for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Default,
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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Div<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Div<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn div_assign(&mut self, rhs: U)
/=
操作。 Read moresource§impl<T, const N: usize> From<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> From<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<T, const N: usize> From<Simd<T, N>> for [T; N]where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> From<Simd<T, N>> for [T; N]where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const N: usize> Hash for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement + Hash,
impl<T, const N: usize> Hash for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Hash,
source§impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,
source§impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,
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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Mul<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Mul<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn mul_assign(&mut self, rhs: U)
*=
操作。 Read moresource§impl<const LANES: usize> Neg for Simd<f32, LANES>where
f32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<f32, LANES>where f32: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<f64, LANES>where
f64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<f64, LANES>where f64: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i16, LANES>where i16: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i32, LANES>where i32: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i64, LANES>where i64: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i8, LANES>where i8: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Neg for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<isize, LANES>where isize: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i16, LANES>where i16: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i32, LANES>where i32: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i64, LANES>where i64: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i8, LANES>where i8: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<isize, LANES>where isize: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<u16, LANES>where
u16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u16, LANES>where u16: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<u32, LANES>where
u32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u32, LANES>where u32: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<u64, LANES>where
u64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u64, LANES>where u64: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<u8, LANES>where
u8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u8, LANES>where u8: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Not for Simd<usize, LANES>where
usize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<usize, LANES>where usize: SimdElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<T, const N: usize> Ord for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement + Ord,
impl<T, const N: usize> Ord for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Ord,
source§impl<T, const N: usize> PartialEq<Simd<T, N>> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement + PartialEq<T>,
impl<T, const N: usize> PartialEq<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialEq<T>,
source§impl<T, const N: usize> PartialOrd<Simd<T, N>> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement + PartialOrd<T>,
impl<T, const N: usize> PartialOrd<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialOrd<T>,
source§impl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,
source§impl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES>where LaneCount<LANES>: SupportedLaneCount,
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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Rem<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<f32, N>> for Simd<f32, N>where f32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<f64, N>> for Simd<f64, N>where f64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Rem<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn rem_assign(&mut self, rhs: U)
%=
操作。 Read moresource§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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Shl<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shl<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn shl_assign(&mut self, rhs: U)
<<=
操作。 Read moresource§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,
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,
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,
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,
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,
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,
source§impl<const N: usize> Shr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i16, N>> for Simd<i16, N>where i16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i32, N>> for Simd<i32, N>where i32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i64, N>> for Simd<i64, N>where i64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i8, N>> for Simd<i8, N>where i8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<isize, N>> for Simd<isize, N>where isize: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u16, N>> for Simd<u16, N>where u16: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where u32: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where u64: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,
source§impl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where usize: SimdElement, LaneCount<N>: SupportedLaneCount,
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,
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)
fn shr_assign(&mut self, rhs: U)
>>=
操作。 Read moresource§impl<T, const LANES: usize> SimdConstPtr for Simd<*const T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> SimdConstPtr for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Usize = Simd<usize, LANES>
type Usize = Simd<usize, LANES>
portable_simd
#86656)usize
的 Vector 与 lanes 的数量相同。§type Isize = Simd<isize, LANES>
type Isize = Simd<isize, LANES>
portable_simd
#86656)isize
的 Vector 与 lanes 的数量相同。§type MutPtr = Simd<*mut T, LANES>
type MutPtr = Simd<*mut T, LANES>
portable_simd
#86656)§type Mask = Mask<isize, LANES>
type Mask = Mask<isize, LANES>
portable_simd
#86656)source§fn is_null(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Mask
fn is_null(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Mask
portable_simd
#86656)true
。source§fn cast_mut(self) -> <Simd<*const T, LANES> as SimdConstPtr>::MutPtr
fn cast_mut(self) -> <Simd<*const T, LANES> as SimdConstPtr>::MutPtr
portable_simd
#86656)source§fn addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize
fn addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize
portable_simd
#86656)source§fn with_addr(
self,
addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize
) -> Simd<*const T, LANES>
fn with_addr( self, addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>
portable_simd
#86656)source§fn expose_addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize
fn expose_addr(self) -> <Simd<*const T, LANES> as SimdConstPtr>::Usize
portable_simd
#86656)Self::from_exposed_addr
中使用的出处部分。source§fn from_exposed_addr(
addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize
) -> Simd<*const T, LANES>
fn from_exposed_addr( addr: <Simd<*const T, LANES> as SimdConstPtr>::Usize ) -> Simd<*const T, LANES>
portable_simd
#86656)source§fn wrapping_offset(
self,
count: <Simd<*const T, LANES> as SimdConstPtr>::Isize
) -> Simd<*const T, LANES>
fn wrapping_offset( self, count: <Simd<*const T, LANES> as SimdConstPtr>::Isize ) -> Simd<*const T, LANES>
portable_simd
#86656)source§impl<const LANES: usize> SimdFloat for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdFloat for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = f32
type Scalar = f32
portable_simd
#86656)§type Bits = Simd<u32, LANES>
type Bits = Simd<u32, LANES>
portable_simd
#86656)source§fn to_bits(self) -> Simd<u32, LANES>
fn to_bits(self) -> Simd<u32, LANES>
portable_simd
#86656)source§fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>
fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<f32, LANES>
fn abs(self) -> Simd<f32, LANES>
portable_simd
#86656)self
中等效索引 lane 的绝对值。source§fn recip(self) -> Simd<f32, LANES>
fn recip(self) -> Simd<f32, LANES>
portable_simd
#86656)1/x
。source§fn to_degrees(self) -> Simd<f32, LANES>
fn to_degrees(self) -> Simd<f32, LANES>
portable_simd
#86656)source§fn to_radians(self) -> Simd<f32, LANES>
fn to_radians(self) -> Simd<f32, LANES>
portable_simd
#86656)source§fn is_sign_positive(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)+0.0
、具有正符号位的 NaN
和正无穷大。source§fn is_sign_negative(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)-0.0
、具有负符号位的 NaN
和负无穷大。source§fn is_nan(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn is_infinite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_finite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn is_subnormal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_normal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn signum(self) -> Simd<f32, LANES>
fn signum(self) -> Simd<f32, LANES>
portable_simd
#86656)source§fn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>
fn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)source§fn simd_min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
fn simd_min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)source§fn simd_max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
fn simd_max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)source§fn simd_clamp(
self,
min: Simd<f32, LANES>,
max: Simd<f32, LANES>
) -> Simd<f32, LANES>
fn simd_clamp( self, min: Simd<f32, LANES>, max: Simd<f32, LANES> ) -> Simd<f32, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = f64
type Scalar = f64
portable_simd
#86656)§type Bits = Simd<u64, LANES>
type Bits = Simd<u64, LANES>
portable_simd
#86656)source§fn to_bits(self) -> Simd<u64, LANES>
fn to_bits(self) -> Simd<u64, LANES>
portable_simd
#86656)source§fn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>
fn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<f64, LANES>
fn abs(self) -> Simd<f64, LANES>
portable_simd
#86656)self
中等效索引 lane 的绝对值。source§fn recip(self) -> Simd<f64, LANES>
fn recip(self) -> Simd<f64, LANES>
portable_simd
#86656)1/x
。source§fn to_degrees(self) -> Simd<f64, LANES>
fn to_degrees(self) -> Simd<f64, LANES>
portable_simd
#86656)source§fn to_radians(self) -> Simd<f64, LANES>
fn to_radians(self) -> Simd<f64, LANES>
portable_simd
#86656)source§fn is_sign_positive(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)+0.0
、具有正符号位的 NaN
和正无穷大。source§fn is_sign_negative(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)-0.0
、具有负符号位的 NaN
和负无穷大。source§fn is_nan(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn is_infinite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_finite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn is_subnormal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_normal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
,则为每个 lane 返回 true。source§fn signum(self) -> Simd<f64, LANES>
fn signum(self) -> Simd<f64, LANES>
portable_simd
#86656)source§fn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>
fn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)source§fn simd_min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
fn simd_min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)source§fn simd_max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
fn simd_max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)source§fn simd_clamp(
self,
min: Simd<f64, LANES>,
max: Simd<f64, LANES>
) -> Simd<f64, LANES>
fn simd_clamp( self, min: Simd<f64, LANES>, max: Simd<f64, LANES> ) -> Simd<f64, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdInt for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = i16
type Scalar = i16
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<i16, LANES>
fn abs(self) -> Simd<i16, LANES>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i16, LANES>
fn saturating_abs(self) -> Simd<i16, LANES>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i16, LANES>
fn saturating_neg(self) -> Simd<i16, LANES>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i16, LANES>
fn signum(self) -> Simd<i16, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdInt for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i32, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = i32
type Scalar = i32
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<i32, LANES>
fn abs(self) -> Simd<i32, LANES>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i32, LANES>
fn saturating_abs(self) -> Simd<i32, LANES>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i32, LANES>
fn saturating_neg(self) -> Simd<i32, LANES>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i32, LANES>
fn signum(self) -> Simd<i32, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdInt for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i64, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = i64
type Scalar = i64
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<i64, LANES>
fn abs(self) -> Simd<i64, LANES>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i64, LANES>
fn saturating_abs(self) -> Simd<i64, LANES>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i64, LANES>
fn saturating_neg(self) -> Simd<i64, LANES>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i64, LANES>
fn signum(self) -> Simd<i64, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdInt for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i8, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = i8
type Scalar = i8
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<i8, LANES>
fn abs(self) -> Simd<i8, LANES>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i8, LANES>
fn saturating_abs(self) -> Simd<i8, LANES>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i8, LANES>
fn saturating_neg(self) -> Simd<i8, LANES>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i8, LANES>
fn signum(self) -> Simd<i8, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§impl<const LANES: usize> SimdInt for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<isize, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<isize as SimdElement>::Mask, LANES>
type Mask = Mask<<isize as SimdElement>::Mask, LANES>
portable_simd
#86656)§type Scalar = isize
type Scalar = isize
portable_simd
#86656)source§fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)source§fn abs(self) -> Simd<isize, LANES>
fn abs(self) -> Simd<isize, LANES>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<isize, LANES>
fn saturating_abs(self) -> Simd<isize, LANES>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<isize, LANES>
fn saturating_neg(self) -> Simd<isize, LANES>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<isize, LANES>
fn signum(self) -> Simd<isize, LANES>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)source§impl<T, const LANES: usize> SimdMutPtr for Simd<*mut T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> SimdMutPtr for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Usize = Simd<usize, LANES>
type Usize = Simd<usize, LANES>
portable_simd
#86656)usize
的 Vector 与 lanes 的数量相同。§type Isize = Simd<isize, LANES>
type Isize = Simd<isize, LANES>
portable_simd
#86656)isize
的 Vector 与 lanes 的数量相同。§type ConstPtr = Simd<*const T, LANES>
type ConstPtr = Simd<*const T, LANES>
portable_simd
#86656)§type Mask = Mask<isize, LANES>
type Mask = Mask<isize, LANES>
portable_simd
#86656)source§fn is_null(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Mask
fn is_null(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Mask
portable_simd
#86656)true
。source§fn cast_const(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::ConstPtr
fn cast_const(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::ConstPtr
portable_simd
#86656)source§fn addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize
fn addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize
portable_simd
#86656)source§fn with_addr(
self,
addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize
) -> Simd<*mut T, LANES>
fn with_addr( self, addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>
portable_simd
#86656)source§fn expose_addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize
fn expose_addr(self) -> <Simd<*mut T, LANES> as SimdMutPtr>::Usize
portable_simd
#86656)Self::from_exposed_addr
中使用的出处部分。source§fn from_exposed_addr(
addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize
) -> Simd<*mut T, LANES>
fn from_exposed_addr( addr: <Simd<*mut T, LANES> as SimdMutPtr>::Usize ) -> Simd<*mut T, LANES>
portable_simd
#86656)source§fn wrapping_offset(
self,
count: <Simd<*mut T, LANES> as SimdMutPtr>::Isize
) -> Simd<*mut T, LANES>
fn wrapping_offset( self, count: <Simd<*mut T, LANES> as SimdMutPtr>::Isize ) -> Simd<*mut T, LANES>
portable_simd
#86656)source§impl<T, const LANES: usize> SimdOrd for Simd<*const T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<*const T, LANES>) -> Simd<*const T, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<T, const LANES: usize> SimdOrd for Simd<*mut T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<*mut T, LANES>) -> Simd<*mut T, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<const LANES: usize> SimdOrd for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
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>
fn simd_max(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>
portable_simd
#86656)other
返回 lane 方向的最大值。source§impl<T, const LANES: usize> SimdPartialEq for Simd<*const T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> SimdPartialEq for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<isize, LANES>
type Mask = Mask<isize, LANES>
portable_simd
#86656)source§impl<T, const LANES: usize> SimdPartialEq for Simd<*mut T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> SimdPartialEq for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<isize, LANES>
type Mask = Mask<isize, LANES>
portable_simd
#86656)source§impl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<f32 as SimdElement>::Mask, LANES>
type Mask = Mask<<f32 as SimdElement>::Mask, LANES>
portable_simd
#86656)source§impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<f64 as SimdElement>::Mask, LANES>
type Mask = Mask<<f64 as SimdElement>::Mask, LANES>
portable_simd
#86656)source§impl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where LaneCount<LANES>: SupportedLaneCount,
§type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
portable_simd
#86656)