Struct faer_core::complex_native::c64conj

#[repr(C)]
pub struct c64conj {
    pub re: f64,
    pub neg_im: f64,
}

Fields

re: f64

neg_im: f64

Trait Implementations

impl Clone for c64conj

fn clone(&self) -> c64conj

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conjugate for c64conj

type Conj = c64

Must have the same layout as Self, and Conj::Unit must have the same layout as Unit.

type Canonical = c64

Must have the same layout as Self, and Canonical::Unit must have the same layout as Unit.

fn canonicalize(self) -> Self::Canonical

Performs the implicit conjugation operation on the given value, returning the canonical form.

impl Debug for c64conj

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

Formats the value using the given formatter.

impl Entity for c64conj

type Unit = c64conj

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

Must be the same as Group<T>.

type GroupThreadSafe<T: Send + Sync> = T

Must be the same as Group<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 PartialEq<c64conj> for c64conj

fn eq(&self, other: &c64conj) -> 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 Zeroable for c64conj

fn zeroed() -> Self

Calls zeroed.

impl Copy for c64conj

impl Pod for c64conj

impl StructuralPartialEq for c64conj