Struct ComplexConj

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

This structure contains the real and imaginary parts of an implicitly 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>

const IS_CANONICAL: bool = false

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>

const N_COMPONENTS: usize = _

const UNIT: GroupFor<Self, ()> = _

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 = ComplexConjGroup<<E as Entity>::Group>

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

type PrefixUnit<'a, S: Simd> = <E as Entity>::PrefixUnit<'a, S>

type SuffixUnit<'a, S: Simd> = <E as Entity>::SuffixUnit<'a, S>

type PrefixMutUnit<'a, S: Simd> = <E as Entity>::PrefixMutUnit<'a, S>

type SuffixMutUnit<'a, S: Simd> = <E as Entity>::SuffixMutUnit<'a, S>

fn faer_first<T>(group: GroupFor<Self, T>) -> T

fn faer_from_units(group: GroupFor<Self, UnitFor<Self>>) -> Self

fn faer_into_units(self) -> GroupFor<Self, UnitFor<Self>>

fn faer_as_ref<T>(group: &GroupFor<Self, T>) -> GroupFor<Self, &T>

fn faer_as_mut<T>(group: &mut GroupFor<Self, T>) -> GroupFor<Self, &mut T>

fn faer_as_ptr<T>(group: *mut GroupFor<Self, T>) -> GroupFor<Self, *mut T>

fn faer_map_impl<T, U>( group: GroupFor<Self, T>, f: &mut impl FnMut(T) -> U, ) -> GroupFor<Self, U>

fn faer_map_with_context<Ctx, T, U>( ctx: Ctx, group: GroupFor<Self, T>, f: &mut impl FnMut(Ctx, T) -> (Ctx, U), ) -> (Ctx, GroupFor<Self, U>)

fn faer_zip<T, U>( first: GroupFor<Self, T>, second: GroupFor<Self, U>, ) -> GroupFor<Self, (T, U)>

fn faer_unzip<T, U>( zipped: GroupFor<Self, (T, U)>, ) -> (GroupFor<Self, T>, GroupFor<Self, U>)

fn faer_into_iter<I: IntoIterator>( iter: GroupFor<Self, I>, ) -> Self::Iter<I::IntoIter>

const IS_REAL: bool = true

fn faer_map<T, U>( group: GroupFor<Self, T>, f: impl FnMut(T) -> U, ) -> GroupFor<Self, U>

fn faer_unzip2<T>(zipped: GroupFor<Self, [T; 2]>) -> [GroupFor<Self, T>; 2]

fn faer_unzip4<T>(zipped: GroupFor<Self, [T; 4]>) -> [GroupFor<Self, T>; 4]

fn faer_unzip8<T>(zipped: GroupFor<Self, [T; 8]>) -> [GroupFor<Self, T>; 8]

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

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

fn faer_deref<T: Copy>(group: GroupFor<Self, &T>) -> GroupFor<Self, T>

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

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

fn faer_into_const<T: IntoConst>( value: GroupFor<Self, T>, ) -> GroupFor<Self, T::Target>

fn faer_copy<T: Copy>(x: &GroupFor<Self, T>) -> GroupFor<Self, T>

impl<T: PartialEq> PartialEq for ComplexConj<T>

fn eq(&self, other: &ComplexConj<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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> StructuralPartialEq for ComplexConj<T>