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(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(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(self, a: Self::c32s, b: Self::c32s) -> Self::c32s

Computes conj(a) * b

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

Computes a * b + c

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

Computes conj(a) * b + c

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

Computes conj(a) * b

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

Computes a * b + c

fn c64s_conj_mul_adde( 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_reduce_sum(self, a: Self::c32s) -> c32

fn c64s_neg(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 f32s_as_simd(slice: &[f32]) -> (&[Self::f32s], &[f32])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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_adde( self, a: Self::f32s, b: Self::f32s, c: Self::f32s ) -> Self::f32s

fn f32_scalar_mul_adde(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(self, a: c32, b: c32) -> c32

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

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

fn c32_scalar_conj_mul_adde(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_adde( self, a: Self::f64s, b: Self::f64s, c: Self::f64s ) -> Self::f64s

fn f64_scalar_mul_adde(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(self, a: c64, b: c64) -> c64

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

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

fn c64_scalar_conj_mul_adde(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

impl Copy for Scalar