Struct faer_core::c64

#[repr(C)]
pub struct c64 {
    pub re: f64,
    pub im: f64,
}

Fields

re: f64

im: f64

Implementations

impl c64

pub fn new(re: f64, im: f64) -> Self

Trait Implementations

impl Add<c64> for c64

type Output = c64

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for c64

fn clone(&self) -> c64

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ComplexField for c64

type Real = f64

fn from_f64(value: f64) -> Self

fn add(&self, rhs: &Self) -> Self

fn sub(&self, rhs: &Self) -> Self

fn mul(&self, rhs: &Self) -> Self

fn neg(&self) -> Self

fn inv(&self) -> Self

fn conj(&self) -> Self

fn sqrt(&self) -> Self

fn scale_real(&self, rhs: &Self::Real) -> Self

Returns the input, scaled by rhs.

fn scale_power_of_two(&self, rhs: &Self::Real) -> Self

Returns the input, scaled by rhs.

fn score(&self) -> Self::Real

Returns either the norm or squared norm of the number.

fn abs(&self) -> Self::Real

fn abs2(&self) -> Self::Real

fn nan() -> Self

fn from_real(real: Self::Real) -> Self

Returns a complex number whose real part is equal to real, and a zero imaginary part.

fn real(&self) -> Self::Real

Returns the real part.

fn imag(&self) -> Self::Real

Returns the imaginary part.

fn zero() -> Self

fn one() -> Self

fn slice_as_simd<S: Simd>( slice: &[Self::Unit] ) -> (&[Self::SimdUnit<S>], &[Self::Unit])

fn slice_as_mut_simd<S: Simd>( slice: &mut [Self::Unit] ) -> (&mut [Self::SimdUnit<S>], &mut [Self::Unit])

fn partial_load_last_unit<S: Simd>( simd: S, slice: &[Self::Unit] ) -> Self::SimdUnit<S>

fn partial_store_last_unit<S: Simd>( simd: S, slice: &mut [Self::Unit], values: Self::SimdUnit<S> )

fn partial_load_unit<S: Simd>( simd: S, slice: &[Self::Unit] ) -> Self::SimdUnit<S>

fn partial_store_unit<S: Simd>( simd: S, slice: &mut [Self::Unit], values: Self::SimdUnit<S> )

fn simd_splat_unit<S: Simd>(simd: S, unit: Self::Unit) -> Self::SimdUnit<S>

fn simd_neg<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_conj<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_add<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_sub<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_mul<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_scale_real<S: Simd>( simd: S, lhs: <Self::Real as Entity>::Group<<Self::Real as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_conj_mul<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_mul_adde<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, acc: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_conj_mul_adde<S: Simd>( simd: S, lhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, rhs: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, acc: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn simd_reduce_add<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> Self

fn simd_abs2_adde<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>, acc: <Self::Real as Entity>::Group<<Self::Real as Entity>::SimdUnit<S>> ) -> <Self::Real as Entity>::Group<<Self::Real as Entity>::SimdUnit<S>>

fn simd_abs2<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self::Real as Entity>::Group<<Self::Real as Entity>::SimdUnit<S>>

fn simd_score<S: Simd>( simd: S, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> ) -> <Self::Real as Entity>::Group<<Self::Real as Entity>::SimdUnit<S>>

fn mul_adde(lhs: &Self, rhs: &Self, acc: &Self) -> Self

fn conj_mul_adde(lhs: &Self, rhs: &Self, acc: &Self) -> Self

fn is_nan(&self) -> bool

fn partial_load<S: Simd>( simd: S, slice: Self::Group<&[Self::Unit]> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn partial_store<S: Simd>( simd: S, slice: Self::Group<&mut [Self::Unit]>, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> )

fn partial_load_last<S: Simd>( simd: S, slice: Self::Group<&[Self::Unit]> ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

fn partial_store_last<S: Simd>( simd: S, slice: Self::Group<&mut [Self::Unit]>, values: <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>> )

fn simd_splat<S: Simd>( simd: S, value: Self ) -> <Self as Entity>::Group<<Self as Entity>::SimdUnit<S>>

impl Conjugate for c64

type Conj = c64conj

type Canonical = c64

fn canonicalize(self) -> Self::Canonical

impl Debug for c64

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

Formats the value using the given formatter.

impl Entity for c64

type Unit = c64

type Index = u64

type SimdUnit<S: Simd> = <S as Simd>::c64s

type SimdMask<S: Simd> = <S as Simd>::m64s

type SimdIndex<S: Simd> = <S as Simd>::u64s

type Group<T> = T

type GroupCopy<T: Copy> = T

type GroupThreadSafe<T: Send + Sync> = T

type Iter<I: Iterator> = I

const N_COMPONENTS: usize = 1usize

const HAS_SIMD: bool = true

const UNIT: Self::GroupCopy<()> = ()

fn from_units(group: Self::Group<Self::Unit>) -> Self

fn into_units(self) -> Self::Group<Self::Unit>

fn as_ref<T>(group: &Self::Group<T>) -> Self::Group<&T>

fn as_mut<T>(group: &mut Self::Group<T>) -> Self::Group<&mut T>

fn map<T, U>(group: Self::Group<T>, f: impl FnMut(T) -> U) -> Self::Group<U>

fn map_with_context<Ctx, T, U>( ctx: Ctx, group: Self::Group<T>, f: impl FnMut(Ctx, T) -> (Ctx, U) ) -> (Ctx, Self::Group<U>)

fn zip<T, U>( first: Self::Group<T>, second: Self::Group<U> ) -> Self::Group<(T, U)>

fn unzip<T, U>(zipped: Self::Group<(T, U)>) -> (Self::Group<T>, Self::Group<U>)

fn into_iter<I: IntoIterator>(iter: Self::Group<I>) -> Self::Iter<I::IntoIter>

fn from_copy<T: Copy>(group: Self::GroupCopy<T>) -> Self::Group<T>

fn into_copy<T: Copy>(group: Self::Group<T>) -> Self::GroupCopy<T>

fn unzip2<T>(zipped: Self::Group<[T; 2]>) -> [Self::Group<T>; 2]

fn unzip4<T>(zipped: Self::Group<[T; 4]>) -> [Self::Group<T>; 4]

fn unzip8<T>(zipped: Self::Group<[T; 8]>) -> [Self::Group<T>; 8]

fn as_arrays<const N: usize, T>( group: Self::Group<&[T]> ) -> (Self::Group<&[[T; N]]>, Self::Group<&[T]>)

fn as_arrays_mut<const N: usize, T>( group: Self::Group<&mut [T]> ) -> (Self::Group<&mut [[T; N]]>, Self::Group<&mut [T]>)

fn deref<T: Clone>(group: Self::Group<&T>) -> Self::Group<T>

fn rb<'short, T: Reborrow<'short>>( value: Self::Group<&'short T> ) -> Self::Group<T::Target>

fn rb_mut<'short, T: ReborrowMut<'short>>( value: Self::Group<&'short mut T> ) -> Self::Group<T::Target>

fn into_const<T: IntoConst>(value: Self::Group<T>) -> Self::Group<T::Target>

fn map_copy<T: Copy, U: Copy>( group: Self::GroupCopy<T>, f: impl FnMut(T) -> U ) -> Self::GroupCopy<U>

fn copy<T: Copy>(group: &Self::Group<T>) -> Self::Group<T>

impl From<Complex<f64>> for c64

fn from(value: Complex64) -> Self

Converts to this type from the input type.

impl From<c64> for Complex64

fn from(value: c64) -> Self

Converts to this type from the input type.

impl Neg for c64

type Output = c64

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<c64> for c64

fn eq(&self, other: &c64) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<c64> for c64

type Output = c64

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Zeroable for c64

fn zeroed() -> Self

Calls zeroed.

impl Copy for c64

impl Pod for c64

impl StructuralPartialEq for c64