Struct faer_core::c32conj

#[repr(C)]
pub struct c32conj {
    pub re: f32,
    pub neg_im: f32,
}

Fields

re: f32

neg_im: f32

Trait Implementations

impl Clone for c32conj

fn clone(&self) -> c32conj

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Conjugate for c32conj

type Conj = c32

type Canonical = c32

fn canonicalize(self) -> Self::Canonical

impl Debug for c32conj

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

Formats the value using the given formatter.

impl Entity for c32conj

type Unit = c32conj

type Index = u32

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

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

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

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 PartialEq<c32conj> for c32conj

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

fn zeroed() -> Self

Calls zeroed.

impl Copy for c32conj

impl Pod for c32conj

impl StructuralPartialEq for c32conj