Struct pulp::Scalar

pub struct Scalar;

Implementations

impl Scalar

pub fn new() -> Self

Trait Implementations

impl Clone for Scalar

fn clone(&self) -> Scalar

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Scalar

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

Formats the value using the given formatter.

impl Default for Scalar

fn default() -> Self

Returns the “default value” for a type.

impl Simd for Scalar

fn vectorize<Op: WithSimd>(self, op: Op) -> Op::Output

type m32s = bool

type f32s = f32

type c32s = Complex<f32>

type i32s = i32

type u32s = u32

type m64s = bool

type f64s = f64

type c64s = Complex<f64>

type i64s = i64

type u64s = u64

fn m32s_not(self, a: Self::m32s) -> Self::m32s

fn m32s_and(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn m32s_or(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn m32s_xor(self, a: Self::m32s, b: Self::m32s) -> Self::m32s

fn f32s_splat(self, value: f32) -> Self::f32s

fn f32s_add(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_sub(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_mul(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_div(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_equal(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn f32s_less_than(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn f32s_less_than_or_equal(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn c32s_splat(self, value: c32) -> Self::c32s

fn c32s_add(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn c32s_sub(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn c32s_mul_e(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

Computes a * b

fn c64s_splat(self, value: c64) -> Self::c64s

fn c64s_add(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn c64s_sub(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn c64s_mul_e(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

Computes a * b

fn m64s_not(self, a: Self::m64s) -> Self::m64s

fn m64s_and(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn m64s_or(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn m64s_xor(self, a: Self::m64s, b: Self::m64s) -> Self::m64s

fn f64s_splat(self, value: f64) -> Self::f64s

fn f64s_add(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_sub(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_mul(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_div(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_equal(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn f64s_less_than(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn f64s_less_than_or_equal(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn u32s_not(self, a: Self::u32s) -> Self::u32s

fn u32s_and(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn u32s_or(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn u32s_xor(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn u64s_not(self, a: Self::u64s) -> Self::u64s

fn u64s_and(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn u64s_or(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn u64s_xor(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn m32s_select_u32s( self, mask: Self::m32s, if_true: Self::u32s, if_false: Self::u32s ) -> Self::u32s

fn m64s_select_u64s( self, mask: Self::m64s, if_true: Self::u64s, if_false: Self::u64s ) -> Self::u64s

fn f32s_min(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_max(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f64s_min(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_max(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn u32s_add(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn u32s_sub(self, a: Self::u32s, b: Self::u32s) -> Self::u32s

fn u64s_add(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn u64s_sub(self, a: Self::u64s, b: Self::u64s) -> Self::u64s

fn u32s_splat(self, value: u32) -> Self::u32s

fn u64s_splat(self, value: u64) -> Self::u64s

fn f32s_reduce_sum(self, a: Self::f32s) -> f32

fn f32s_reduce_product(self, a: Self::f32s) -> f32

fn f32s_reduce_min(self, a: Self::f32s) -> f32

fn f32s_reduce_max(self, a: Self::f32s) -> f32

fn f64s_reduce_sum(self, a: Self::f64s) -> f64

fn f64s_reduce_product(self, a: Self::f64s) -> f64

fn f64s_reduce_min(self, a: Self::f64s) -> f64

fn f64s_reduce_max(self, a: Self::f64s) -> f64

fn f32s_mul_add(self, a: Self::f32s, b: Self::f32s, c: Self::f32s) -> Self::f32s

fn f64s_mul_add(self, a: Self::f64s, b: Self::f64s, c: Self::f64s) -> Self::f64s

fn c32s_abs2(self, a: Self::c32s) -> Self::c32s

Contains the square of the norm in both the real and imaginary components.

fn c64s_abs2(self, a: Self::c64s) -> Self::c64s

Contains the square of the norm in both the real and imaginary components.

fn u32s_partial_load(self, slice: &[u32]) -> Self::u32s

fn u32s_partial_store(self, slice: &mut [u32], values: Self::u32s)

fn u64s_partial_load(self, slice: &[u64]) -> Self::u64s

fn u64s_partial_store(self, slice: &mut [u64], values: Self::u64s)

fn c64s_partial_load(self, slice: &[c64]) -> Self::c64s

fn c64s_partial_store(self, slice: &mut [c64], values: Self::c64s)

fn u32s_partial_load_last(self, slice: &[u32]) -> Self::u32s

fn u32s_partial_store_last(self, slice: &mut [u32], values: Self::u32s)

fn u64s_partial_load_last(self, slice: &[u64]) -> Self::u64s

fn u64s_partial_store_last(self, slice: &mut [u64], values: Self::u64s)

fn c64s_partial_load_last(self, slice: &[c64]) -> Self::c64s

fn c64s_partial_store_last(self, slice: &mut [c64], values: Self::c64s)

fn c32s_conj_mul_e(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

Computes conj(a) * b

fn c32s_mul_add_e( self, a: Self::c32s, b: Self::c32s, c: Self::c32s ) -> Self::c32s

Computes a * b + c

fn c32s_conj_mul_add_e( self, a: Self::c32s, b: Self::c32s, c: Self::c32s ) -> Self::c32s

Computes conj(a) * b + c

fn c64s_conj_mul_e(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

Computes conj(a) * b

fn c64s_mul_add_e( self, a: Self::c64s, b: Self::c64s, c: Self::c64s ) -> Self::c64s

Computes a * b + c

fn c64s_conj_mul_add_e( self, a: Self::c64s, b: Self::c64s, c: Self::c64s ) -> Self::c64s

Computes conj(a) * b + c

fn c32s_conj(self, a: Self::c32s) -> Self::c32s

fn c64s_conj(self, a: Self::c64s) -> Self::c64s

fn c32s_neg(self, a: Self::c32s) -> Self::c32s

fn c32s_swap_re_im(self, a: Self::c32s) -> Self::c32s

fn c32s_reduce_sum(self, a: Self::c32s) -> c32

fn c64s_neg(self, a: Self::c64s) -> Self::c64s

fn c64s_swap_re_im(self, a: Self::c64s) -> Self::c64s

fn c64s_reduce_sum(self, a: Self::c64s) -> c64

fn u32s_wrapping_dyn_shl(self, a: Self::u32s, amount: Self::u32s) -> Self::u32s

fn u32s_wrapping_dyn_shr(self, a: Self::u32s, amount: Self::u32s) -> Self::u32s

fn u32s_widening_mul( self, a: Self::u32s, b: Self::u32s ) -> (Self::u32s, Self::u32s)

fn u32s_less_than(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn u32s_greater_than(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn u32s_less_than_or_equal(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn u32s_greater_than_or_equal(self, a: Self::u32s, b: Self::u32s) -> Self::m32s

fn c32s_mul(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn c32s_conj_mul(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

fn c32s_mul_add(self, a: Self::c32s, b: Self::c32s, c: Self::c32s) -> Self::c32s

fn c32s_conj_mul_add( self, a: Self::c32s, b: Self::c32s, c: Self::c32s ) -> Self::c32s

fn c64s_mul(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn c64s_conj_mul(self, a: Self::c64s, b: Self::c64s) -> Self::c64s

fn c64s_mul_add(self, a: Self::c64s, b: Self::c64s, c: Self::c64s) -> Self::c64s

fn c64s_conj_mul_add( self, a: Self::c64s, b: Self::c64s, c: Self::c64s ) -> Self::c64s

unsafe fn u32s_mask_load_ptr( self, mask: Self::m32s, ptr: *const u32, or: Self::u32s ) -> Self::u32s

Safety

unsafe fn c32s_mask_load_ptr( self, mask: Self::m32s, ptr: *const c32, or: Self::c32s ) -> Self::c32s

Safety

unsafe fn u32s_mask_store_ptr( self, mask: Self::m32s, ptr: *mut u32, values: Self::u32s )

Safety

unsafe fn c32s_mask_store_ptr( self, mask: Self::m32s, ptr: *mut c32, values: Self::c32s )

Safety

unsafe fn u64s_mask_load_ptr( self, mask: Self::m64s, ptr: *const u64, or: Self::u64s ) -> Self::u64s

Safety

unsafe fn c64s_mask_load_ptr( self, mask: Self::m64s, ptr: *const c64, or: Self::c64s ) -> Self::c64s

Safety

unsafe fn u64s_mask_store_ptr( self, mask: Self::m64s, ptr: *mut u64, values: Self::u64s )

Safety

unsafe fn c64s_mask_store_ptr( self, mask: Self::m64s, ptr: *mut c64, values: Self::c64s )

Safety

fn u64s_less_than(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn u64s_greater_than(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn u64s_less_than_or_equal(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn u64s_greater_than_or_equal(self, a: Self::u64s, b: Self::u64s) -> Self::m64s

fn u32s_rotate_right(self, a: Self::u32s, _amount: usize) -> Self::u32s

fn c32s_rotate_right(self, a: Self::c32s, _amount: usize) -> Self::c32s

fn u64s_rotate_right(self, a: Self::u64s, _amount: usize) -> Self::u64s

fn c64s_rotate_right(self, a: Self::c64s, _amount: usize) -> Self::c64s

fn f32s_as_simd(slice: &[f32]) -> (&[Self::f32s], &[f32])

fn f32s_as_mut_simd(slice: &mut [f32]) -> (&mut [Self::f32s], &mut [f32])

fn f32s_as_uninit_mut_simd( slice: &mut [MaybeUninit<f32>] ) -> (&mut [MaybeUninit<Self::f32s>], &mut [MaybeUninit<f32>])

fn c32s_as_simd(slice: &[c32]) -> (&[Self::c32s], &[c32])

fn c32s_as_mut_simd(slice: &mut [c32]) -> (&mut [Self::c32s], &mut [c32])

fn c32s_as_uninit_mut_simd( slice: &mut [MaybeUninit<c32>] ) -> (&mut [MaybeUninit<Self::c32s>], &mut [MaybeUninit<c32>])

fn i32s_as_simd(slice: &[i32]) -> (&[Self::i32s], &[i32])

fn i32s_as_mut_simd(slice: &mut [i32]) -> (&mut [Self::i32s], &mut [i32])

fn i32s_as_uninit_mut_simd( slice: &mut [MaybeUninit<i32>] ) -> (&mut [MaybeUninit<Self::i32s>], &mut [MaybeUninit<i32>])

fn u32s_as_simd(slice: &[u32]) -> (&[Self::u32s], &[u32])

fn u32s_as_mut_simd(slice: &mut [u32]) -> (&mut [Self::u32s], &mut [u32])

fn u32s_as_uninit_mut_simd( slice: &mut [MaybeUninit<u32>] ) -> (&mut [MaybeUninit<Self::u32s>], &mut [MaybeUninit<u32>])

fn f64s_as_simd(slice: &[f64]) -> (&[Self::f64s], &[f64])

fn f64s_as_mut_simd(slice: &mut [f64]) -> (&mut [Self::f64s], &mut [f64])

fn f64s_as_uninit_mut_simd( slice: &mut [MaybeUninit<f64>] ) -> (&mut [MaybeUninit<Self::f64s>], &mut [MaybeUninit<f64>])

fn c64s_as_simd(slice: &[c64]) -> (&[Self::c64s], &[c64])

fn c64s_as_mut_simd(slice: &mut [c64]) -> (&mut [Self::c64s], &mut [c64])

fn c64s_as_uninit_mut_simd( slice: &mut [MaybeUninit<c64>] ) -> (&mut [MaybeUninit<Self::c64s>], &mut [MaybeUninit<c64>])

fn i64s_as_simd(slice: &[i64]) -> (&[Self::i64s], &[i64])

fn i64s_as_mut_simd(slice: &mut [i64]) -> (&mut [Self::i64s], &mut [i64])

fn i64s_as_uninit_mut_simd( slice: &mut [MaybeUninit<i64>] ) -> (&mut [MaybeUninit<Self::i64s>], &mut [MaybeUninit<i64>])

fn u64s_as_simd(slice: &[u64]) -> (&[Self::u64s], &[u64])

fn u64s_as_mut_simd(slice: &mut [u64]) -> (&mut [Self::u64s], &mut [u64])

fn u64s_as_uninit_mut_simd( slice: &mut [MaybeUninit<u64>] ) -> (&mut [MaybeUninit<Self::u64s>], &mut [MaybeUninit<u64>])

fn i32s_align_offset(self, ptr: *const i32, len: usize) -> Offset<Self::m32s>

fn f32s_align_offset(self, ptr: *const f32, len: usize) -> Offset<Self::m32s>

fn u32s_align_offset(self, ptr: *const u32, len: usize) -> Offset<Self::m32s>

fn c32s_align_offset(self, ptr: *const c32, len: usize) -> Offset<Self::m32s>

fn i64s_align_offset(self, ptr: *const i64, len: usize) -> Offset<Self::m64s>

fn f64s_align_offset(self, ptr: *const f64, len: usize) -> Offset<Self::m64s>

fn u64s_align_offset(self, ptr: *const u64, len: usize) -> Offset<Self::m64s>

fn c64s_align_offset(self, ptr: *const c64, len: usize) -> Offset<Self::m64s>

fn i32s_as_aligned_simd( self, slice: &[i32], offset: Offset<Self::m32s> ) -> (Prefix<'_, i32, Self, Self::m32s>, &[Self::i32s], Suffix<'_, i32, Self, Self::m32s>)

fn f32s_as_aligned_simd( self, slice: &[f32], offset: Offset<Self::m32s> ) -> (Prefix<'_, f32, Self, Self::m32s>, &[Self::f32s], Suffix<'_, f32, Self, Self::m32s>)

fn u32s_as_aligned_simd( self, slice: &[u32], offset: Offset<Self::m32s> ) -> (Prefix<'_, u32, Self, Self::m32s>, &[Self::u32s], Suffix<'_, u32, Self, Self::m32s>)

fn c32s_as_aligned_simd( self, slice: &[c32], offset: Offset<Self::m32s> ) -> (Prefix<'_, c32, Self, Self::m32s>, &[Self::c32s], Suffix<'_, c32, Self, Self::m32s>)

fn i64s_as_aligned_simd( self, slice: &[i64], offset: Offset<Self::m64s> ) -> (Prefix<'_, i64, Self, Self::m64s>, &[Self::i64s], Suffix<'_, i64, Self, Self::m64s>)

fn f64s_as_aligned_simd( self, slice: &[f64], offset: Offset<Self::m64s> ) -> (Prefix<'_, f64, Self, Self::m64s>, &[Self::f64s], Suffix<'_, f64, Self, Self::m64s>)

fn u64s_as_aligned_simd( self, slice: &[u64], offset: Offset<Self::m64s> ) -> (Prefix<'_, u64, Self, Self::m64s>, &[Self::u64s], Suffix<'_, u64, Self, Self::m64s>)

fn c64s_as_aligned_simd( self, slice: &[c64], offset: Offset<Self::m64s> ) -> (Prefix<'_, c64, Self, Self::m64s>, &[Self::c64s], Suffix<'_, c64, Self, Self::m64s>)

fn i32s_as_aligned_mut_simd( self, slice: &mut [i32], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, i32, Self, Self::m32s>, &mut [Self::i32s], SuffixMut<'_, i32, Self, Self::m32s>)

fn f32s_as_aligned_mut_simd( self, slice: &mut [f32], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, f32, Self, Self::m32s>, &mut [Self::f32s], SuffixMut<'_, f32, Self, Self::m32s>)

fn u32s_as_aligned_mut_simd( self, slice: &mut [u32], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, u32, Self, Self::m32s>, &mut [Self::u32s], SuffixMut<'_, u32, Self, Self::m32s>)

fn c32s_as_aligned_mut_simd( self, slice: &mut [c32], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, c32, Self, Self::m32s>, &mut [Self::c32s], SuffixMut<'_, c32, Self, Self::m32s>)

fn i64s_as_aligned_mut_simd( self, slice: &mut [i64], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, i64, Self, Self::m64s>, &mut [Self::i64s], SuffixMut<'_, i64, Self, Self::m64s>)

fn f64s_as_aligned_mut_simd( self, slice: &mut [f64], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, f64, Self, Self::m64s>, &mut [Self::f64s], SuffixMut<'_, f64, Self, Self::m64s>)

fn u64s_as_aligned_mut_simd( self, slice: &mut [u64], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, u64, Self, Self::m64s>, &mut [Self::u64s], SuffixMut<'_, u64, Self, Self::m64s>)

fn c64s_as_aligned_mut_simd( self, slice: &mut [c64], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, c64, Self, Self::m64s>, &mut [Self::c64s], SuffixMut<'_, c64, Self, Self::m64s>)

fn i32s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<i32>], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, MaybeUninit<i32>, Self, Self::m32s>, &mut [MaybeUninit<Self::i32s>], SuffixMut<'_, MaybeUninit<i32>, Self, Self::m32s>)

fn f32s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<f32>], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, MaybeUninit<f32>, Self, Self::m32s>, &mut [MaybeUninit<Self::f32s>], SuffixMut<'_, MaybeUninit<f32>, Self, Self::m32s>)

fn u32s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<u32>], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, MaybeUninit<u32>, Self, Self::m32s>, &mut [MaybeUninit<Self::u32s>], SuffixMut<'_, MaybeUninit<u32>, Self, Self::m32s>)

fn c32s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<c32>], offset: Offset<Self::m32s> ) -> (PrefixMut<'_, MaybeUninit<c32>, Self, Self::m32s>, &mut [MaybeUninit<Self::c32s>], SuffixMut<'_, MaybeUninit<c32>, Self, Self::m32s>)

fn i64s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<i64>], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, MaybeUninit<i64>, Self, Self::m64s>, &mut [MaybeUninit<Self::i64s>], SuffixMut<'_, MaybeUninit<i64>, Self, Self::m64s>)

fn f64s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<f64>], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, MaybeUninit<f64>, Self, Self::m64s>, &mut [MaybeUninit<Self::f64s>], SuffixMut<'_, MaybeUninit<f64>, Self, Self::m64s>)

fn u64s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<u64>], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, MaybeUninit<u64>, Self, Self::m64s>, &mut [MaybeUninit<Self::u64s>], SuffixMut<'_, MaybeUninit<u64>, Self, Self::m64s>)

fn c64s_as_aligned_uninit_mut_simd( self, slice: &mut [MaybeUninit<c64>], offset: Offset<Self::m64s> ) -> (PrefixMut<'_, MaybeUninit<c64>, Self, Self::m64s>, &mut [MaybeUninit<Self::c64s>], SuffixMut<'_, MaybeUninit<c64>, Self, Self::m64s>)

unsafe fn i32s_mask_load_ptr( self, mask: Self::m32s, ptr: *const i32, or: Self::i32s ) -> Self::i32s

Safety

unsafe fn f32s_mask_load_ptr( self, mask: Self::m32s, ptr: *const f32, or: Self::f32s ) -> Self::f32s

Safety

unsafe fn i32s_mask_store_ptr( self, mask: Self::m32s, ptr: *mut i32, values: Self::i32s )

Safety

unsafe fn f32s_mask_store_ptr( self, mask: Self::m32s, ptr: *mut f32, values: Self::f32s )

Safety

unsafe fn i64s_mask_load_ptr( self, mask: Self::m64s, ptr: *const i64, or: Self::i64s ) -> Self::i64s

Safety

unsafe fn f64s_mask_load_ptr( self, mask: Self::m64s, ptr: *const f64, or: Self::f64s ) -> Self::f64s

Safety

unsafe fn i64s_mask_store_ptr( self, mask: Self::m64s, ptr: *mut i64, values: Self::i64s )

Safety

unsafe fn f64s_mask_store_ptr( self, mask: Self::m64s, ptr: *mut f64, values: Self::f64s )

Safety

fn i32s_partial_load(self, slice: &[i32]) -> Self::i32s

fn i32s_partial_store(self, slice: &mut [i32], values: Self::i32s)

fn i64s_partial_load(self, slice: &[i64]) -> Self::i64s

fn i64s_partial_store(self, slice: &mut [i64], values: Self::i64s)

fn f32s_partial_load(self, slice: &[f32]) -> Self::f32s

fn f32s_partial_store(self, slice: &mut [f32], values: Self::f32s)

fn f64s_partial_load(self, slice: &[f64]) -> Self::f64s

fn f64s_partial_store(self, slice: &mut [f64], values: Self::f64s)

fn c32s_partial_load(self, slice: &[c32]) -> Self::c32s

fn c32s_partial_store(self, slice: &mut [c32], values: Self::c32s)

fn i32s_partial_load_last(self, slice: &[i32]) -> Self::i32s

fn i32s_partial_store_last(self, slice: &mut [i32], values: Self::i32s)

fn i64s_partial_load_last(self, slice: &[i64]) -> Self::i64s

fn i64s_partial_store_last(self, slice: &mut [i64], values: Self::i64s)

fn f32s_partial_load_last(self, slice: &[f32]) -> Self::f32s

fn f32s_partial_store_last(self, slice: &mut [f32], values: Self::f32s)

fn f64s_partial_load_last(self, slice: &[f64]) -> Self::f64s

fn f64s_partial_store_last(self, slice: &mut [f64], values: Self::f64s)

fn c32s_partial_load_last(self, slice: &[c32]) -> Self::c32s

fn c32s_partial_store_last(self, slice: &mut [c32], values: Self::c32s)

fn i32s_not(self, a: Self::i32s) -> Self::i32s

fn i32s_and(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn i32s_or(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn i32s_xor(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn i64s_not(self, a: Self::i64s) -> Self::i64s

fn i64s_and(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn i64s_or(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn i64s_xor(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn f32s_not(self, a: Self::f32s) -> Self::f32s

fn f32s_and(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_or(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f32s_xor(self, a: Self::f32s, b: Self::f32s) -> Self::f32s

fn f64s_not(self, a: Self::f64s) -> Self::f64s

fn f64s_and(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_or(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn f64s_xor(self, a: Self::f64s, b: Self::f64s) -> Self::f64s

fn m32s_select_i32s( self, mask: Self::m32s, if_true: Self::i32s, if_false: Self::i32s ) -> Self::i32s

fn m32s_select_f32s( self, mask: Self::m32s, if_true: Self::f32s, if_false: Self::f32s ) -> Self::f32s

fn m64s_select_i64s( self, mask: Self::m64s, if_true: Self::i64s, if_false: Self::i64s ) -> Self::i64s

fn m64s_select_f64s( self, mask: Self::m64s, if_true: Self::f64s, if_false: Self::f64s ) -> Self::f64s

fn i32s_splat(self, value: i32) -> Self::i32s

fn i32s_add(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn i32s_sub(self, a: Self::i32s, b: Self::i32s) -> Self::i32s

fn i64s_splat(self, value: i64) -> Self::i64s

fn i64s_add(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn i64s_sub(self, a: Self::i64s, b: Self::i64s) -> Self::i64s

fn f32s_abs(self, a: Self::f32s) -> Self::f32s

fn f32s_neg(self, a: Self::f32s) -> Self::f32s

fn f32s_mul_add_e( self, a: Self::f32s, b: Self::f32s, c: Self::f32s ) -> Self::f32s

fn f32_scalar_mul_add_e(self, a: f32, b: f32, c: f32) -> f32

fn f32_scalar_mul_add(self, a: f32, b: f32, c: f32) -> f32

fn f32s_greater_than(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn f32s_greater_than_or_equal(self, a: Self::f32s, b: Self::f32s) -> Self::m32s

fn c32_scalar_mul_e(self, a: c32, b: c32) -> c32

fn c32_scalar_mul(self, a: c32, b: c32) -> c32

fn c32_scalar_conj_mul_e(self, a: c32, b: c32) -> c32

fn c32_scalar_conj_mul(self, a: c32, b: c32) -> c32

fn c32_scalar_mul_add_e(self, a: c32, b: c32, c: c32) -> c32

fn c32_scalar_mul_add(self, a: c32, b: c32, c: c32) -> c32

fn c32_scalar_conj_mul_add_e(self, a: c32, b: c32, c: c32) -> c32

fn c32_scalar_conj_mul_add(self, a: c32, b: c32, c: c32) -> c32

fn f64s_abs(self, a: Self::f64s) -> Self::f64s

fn f64s_neg(self, a: Self::f64s) -> Self::f64s

fn f64s_mul_add_e( self, a: Self::f64s, b: Self::f64s, c: Self::f64s ) -> Self::f64s

fn f64_scalar_mul_add_e(self, a: f64, b: f64, c: f64) -> f64

fn f64_scalar_mul_add(self, a: f64, b: f64, c: f64) -> f64

fn f64s_greater_than(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn f64s_greater_than_or_equal(self, a: Self::f64s, b: Self::f64s) -> Self::m64s

fn c64_scalar_mul_e(self, a: c64, b: c64) -> c64

fn c64_scalar_mul(self, a: c64, b: c64) -> c64

fn c64_scalar_conj_mul_e(self, a: c64, b: c64) -> c64

fn c64_scalar_conj_mul(self, a: c64, b: c64) -> c64

fn c64_scalar_mul_add_e(self, a: c64, b: c64, c: c64) -> c64

fn c64_scalar_mul_add(self, a: c64, b: c64, c: c64) -> c64

fn c64_scalar_conj_mul_add_e(self, a: c64, b: c64, c: c64) -> c64

fn c64_scalar_conj_mul_add(self, a: c64, b: c64, c: c64) -> c64

fn f32s_transmute_i32s(self, a: Self::f32s) -> Self::i32s

fn f32s_transmute_u32s(self, a: Self::f32s) -> Self::u32s

fn i32s_transmute_f32s(self, a: Self::i32s) -> Self::f32s

fn i32s_transmute_u32s(self, a: Self::i32s) -> Self::u32s

fn u32s_transmute_f32s(self, a: Self::u32s) -> Self::f32s

fn u32s_transmute_i32s(self, a: Self::u32s) -> Self::i32s

fn f64s_transmute_i64s(self, a: Self::f64s) -> Self::i64s

fn f64s_transmute_u64s(self, a: Self::f64s) -> Self::u64s

fn i64s_transmute_f64s(self, a: Self::i64s) -> Self::f64s

fn i64s_transmute_u64s(self, a: Self::i64s) -> Self::u64s

fn u64s_transmute_f64s(self, a: Self::u64s) -> Self::f64s

fn u64s_transmute_i64s(self, a: Self::u64s) -> Self::i64s

fn i32s_rotate_right(self, a: Self::i32s, amount: usize) -> Self::i32s

fn f32s_rotate_right(self, a: Self::f32s, amount: usize) -> Self::f32s

fn i64s_rotate_right(self, a: Self::i64s, amount: usize) -> Self::i64s

fn f64s_rotate_right(self, a: Self::f64s, amount: usize) -> Self::f64s

fn i32s_rotate_left(self, a: Self::i32s, amount: usize) -> Self::i32s

fn f32s_rotate_left(self, a: Self::f32s, amount: usize) -> Self::f32s

fn u32s_rotate_left(self, a: Self::u32s, amount: usize) -> Self::u32s

fn c32s_rotate_left(self, a: Self::c32s, amount: usize) -> Self::c32s

fn i64s_rotate_left(self, a: Self::i64s, amount: usize) -> Self::i64s

fn f64s_rotate_left(self, a: Self::f64s, amount: usize) -> Self::f64s

fn u64s_rotate_left(self, a: Self::u64s, amount: usize) -> Self::u64s

fn c64s_rotate_left(self, a: Self::c64s, amount: usize) -> Self::c64s

impl Copy for Scalar