Struct faer_entity::complex_split::ComplexConj

#[repr(C)]
pub struct ComplexConj<T> {
    pub re: T,
    pub neg_im: T,
}

This structure contains the real and imaginary parts of an implicity conjugated value.

Fields

re: T

neg_im: T

Trait Implementations

impl<T: Clone> Clone for ComplexConj<T>

fn clone(&self) -> ComplexConj<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E: Entity + ComplexField> Conjugate for ComplexConj<E>

type Conj = Complex<E>

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

type Canonical = Complex<E>

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<T: Debug> Debug for ComplexConj<T>

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

Formats the value using the given formatter.

impl<E: Entity> Entity for ComplexConj<E>

type Unit = <E as Entity>::Unit

type Index = <E as Entity>::Index

type SimdUnit<S: Simd> = <E as Entity>::SimdUnit<S>

type SimdMask<S: Simd> = <E as Entity>::SimdMask<S>

type SimdIndex<S: Simd> = <E as Entity>::SimdIndex<S>

type Group<T> = ComplexConj<<E as Entity>::Group<T>>

If Group<()> == (), then that must imply Group<T> == T.

type GroupCopy<T: Copy> = ComplexConj<<E as Entity>::GroupCopy<T>>

Must be the same as Group<T>.

type Iter<I: Iterator> = ComplexConjIter<<E as Entity>::Iter<I>>

const N_COMPONENTS: usize = _

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 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: Copy>(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 from_copy<T: Copy>(group: Self::GroupCopy<T>) -> Self::Group<T>

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

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<T: PartialEq> PartialEq for ComplexConj<T>

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

fn zeroed() -> Self

Calls zeroed.

impl<T: Copy> Copy for ComplexConj<T>

impl<T: Eq> Eq for ComplexConj<T>

impl<T: Pod> Pod for ComplexConj<T>

impl<T> StructuralEq for ComplexConj<T>

impl<T> StructuralPartialEq for ComplexConj<T>