Trait extendr_api::prelude::modules::core::Entity

pub unsafe trait Entity:
    Copy
    + Pod
    + PartialEq
    + Send
    + Sync
    + Debug
    + 'static {
    type Group: ForType + ForCopyType + ForDebugType;
    type Unit: Copy + Pod + PartialEq + Send + Sync + Debug + 'static;
    type Index: Copy + Pod + Send + Sync + Debug + 'static;
    type SimdUnit<S: Simd>: Copy + Pod + Send + Sync + Debug + 'static;
    type SimdMask<S: Simd>: Copy + Send + Sync + Debug + 'static;
    type SimdIndex<S: Simd>: Copy + Pod + Send + Sync + Debug + 'static;
    type Iter<I: Iterator>: Iterator<Item = <Self::Group as ForType>::FaerOf<<I as Iterator>::Item>>;
    type PrefixUnit<'a, S: Simd>: Copy + Read<Output = Self::SimdUnit<S>>;
    type SuffixUnit<'a, S: Simd>: Copy + Read<Output = Self::SimdUnit<S>>;
    type PrefixMutUnit<'a, S: Simd>: Write<Output = Self::SimdUnit<S>> + IntoConst<Target = Self::PrefixUnit<'a, S>> + UniversalReborrow + UniversalReborrowMut;
    type SuffixMutUnit<'a, S: Simd>: Write<Output = Self::SimdUnit<S>> + IntoConst<Target = Self::SuffixUnit<'a, S>> + UniversalReborrow + UniversalReborrowMut;
Show 2 associated constants and 22 methods const N_COMPONENTS: usize; const UNIT: <Self::Group as ForType>::FaerOf<()>; // Required methods fn faer_first<T>(group: <Self::Group as ForType>::FaerOf<T>) -> T; fn faer_from_units( group: <Self::Group as ForType>::FaerOf<Self::Unit>, ) -> Self; fn faer_into_units(self) -> <Self::Group as ForType>::FaerOf<Self::Unit>; fn faer_as_ref<T>( group: &<Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<&T>; fn faer_as_mut<T>( group: &mut <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<&mut T>; fn faer_as_ptr<T>( group: *mut <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<*mut T>; fn faer_map_impl<T, U>( group: <Self::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(T) -> U, ) -> <Self::Group as ForType>::FaerOf<U>; fn faer_zip<T, U>( first: <Self::Group as ForType>::FaerOf<T>, second: <Self::Group as ForType>::FaerOf<U>, ) -> <Self::Group as ForType>::FaerOf<(T, U)>; fn faer_unzip<T, U>( zipped: <Self::Group as ForType>::FaerOf<(T, U)>, ) -> (<Self::Group as ForType>::FaerOf<T>, <Self::Group as ForType>::FaerOf<U>); fn faer_map_with_context<Ctx, T, U>( ctx: Ctx, group: <Self::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(Ctx, T) -> (Ctx, U), ) -> (Ctx, <Self::Group as ForType>::FaerOf<U>); fn faer_into_iter<I>( iter: <Self::Group as ForType>::FaerOf<I>, ) -> Self::Iter<<I as IntoIterator>::IntoIter> where I: IntoIterator; // Provided methods fn faer_map<T, U>( group: <Self::Group as ForType>::FaerOf<T>, f: impl FnMut(T) -> U, ) -> <Self::Group as ForType>::FaerOf<U> { ... } fn faer_unzip2<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 2]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 2] { ... } fn faer_unzip4<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 4]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 4] { ... } fn faer_unzip8<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 8]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 8] { ... } fn faer_as_arrays<const N: usize, T>( group: <Self::Group as ForType>::FaerOf<&[T]>, ) -> (<Self::Group as ForType>::FaerOf<&[[T; N]]>, <Self::Group as ForType>::FaerOf<&[T]>) { ... } fn faer_as_arrays_mut<const N: usize, T>( group: <Self::Group as ForType>::FaerOf<&mut [T]>, ) -> (<Self::Group as ForType>::FaerOf<&mut [[T; N]]>, <Self::Group as ForType>::FaerOf<&mut [T]>) { ... } fn faer_deref<T>( group: <Self::Group as ForType>::FaerOf<&T>, ) -> <Self::Group as ForType>::FaerOf<T> where T: Copy { ... } fn faer_rb<'short, T>( value: <Self::Group as ForType>::FaerOf<&'short T>, ) -> <Self::Group as ForType>::FaerOf<<T as Reborrow<'short>>::Target> where T: Reborrow<'short> { ... } fn faer_rb_mut<'short, T>( value: <Self::Group as ForType>::FaerOf<&'short mut T>, ) -> <Self::Group as ForType>::FaerOf<<T as ReborrowMut<'short>>::Target> where T: ReborrowMut<'short> { ... } fn faer_into_const<T>( value: <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<<T as IntoConst>::Target> where T: IntoConst { ... } fn faer_copy<T>( x: &<Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<T> where T: Copy { ... }
}
Expand description

Unstable core trait for describing how a scalar value may be split up into individual component.

For example, f64 is treated as a single indivisible unit, but num_complex::Complex<f64> is split up into its real and imaginary components, with each one being stored in a separate container.

§Safety

The associated types and functions must fulfill their respective contracts.

Required Associated Types§

type Group: ForType + ForCopyType + ForDebugType

type Unit: Copy + Pod + PartialEq + Send + Sync + Debug + 'static

type Index: Copy + Pod + Send + Sync + Debug + 'static

type SimdUnit<S: Simd>: Copy + Pod + Send + Sync + Debug + 'static

type SimdMask<S: Simd>: Copy + Send + Sync + Debug + 'static

type SimdIndex<S: Simd>: Copy + Pod + Send + Sync + Debug + 'static

type Iter<I: Iterator>: Iterator<Item = <Self::Group as ForType>::FaerOf<<I as Iterator>::Item>>

type PrefixUnit<'a, S: Simd>: Copy + Read<Output = Self::SimdUnit<S>>

type SuffixUnit<'a, S: Simd>: Copy + Read<Output = Self::SimdUnit<S>>

type PrefixMutUnit<'a, S: Simd>: Write<Output = Self::SimdUnit<S>> + IntoConst<Target = Self::PrefixUnit<'a, S>> + UniversalReborrow + UniversalReborrowMut

type SuffixMutUnit<'a, S: Simd>: Write<Output = Self::SimdUnit<S>> + IntoConst<Target = Self::SuffixUnit<'a, S>> + UniversalReborrow + UniversalReborrowMut

Required Associated Constants§

const N_COMPONENTS: usize

const UNIT: <Self::Group as ForType>::FaerOf<()>

Required Methods§

fn faer_first<T>(group: <Self::Group as ForType>::FaerOf<T>) -> T

fn faer_from_units(group: <Self::Group as ForType>::FaerOf<Self::Unit>) -> Self

fn faer_into_units(self) -> <Self::Group as ForType>::FaerOf<Self::Unit>

fn faer_as_ref<T>( group: &<Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<&T>

fn faer_as_mut<T>( group: &mut <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<&mut T>

fn faer_as_ptr<T>( group: *mut <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<*mut T>

fn faer_map_impl<T, U>( group: <Self::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(T) -> U, ) -> <Self::Group as ForType>::FaerOf<U>

fn faer_zip<T, U>( first: <Self::Group as ForType>::FaerOf<T>, second: <Self::Group as ForType>::FaerOf<U>, ) -> <Self::Group as ForType>::FaerOf<(T, U)>

fn faer_unzip<T, U>( zipped: <Self::Group as ForType>::FaerOf<(T, U)>, ) -> (<Self::Group as ForType>::FaerOf<T>, <Self::Group as ForType>::FaerOf<U>)

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

fn faer_into_iter<I>( iter: <Self::Group as ForType>::FaerOf<I>, ) -> Self::Iter<<I as IntoIterator>::IntoIter>
where I: IntoIterator,

Provided Methods§

fn faer_map<T, U>( group: <Self::Group as ForType>::FaerOf<T>, f: impl FnMut(T) -> U, ) -> <Self::Group as ForType>::FaerOf<U>

fn faer_unzip2<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 2]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 2]

fn faer_unzip4<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 4]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 4]

fn faer_unzip8<T>( zipped: <Self::Group as ForType>::FaerOf<[T; 8]>, ) -> [<Self::Group as ForType>::FaerOf<T>; 8]

fn faer_as_arrays<const N: usize, T>( group: <Self::Group as ForType>::FaerOf<&[T]>, ) -> (<Self::Group as ForType>::FaerOf<&[[T; N]]>, <Self::Group as ForType>::FaerOf<&[T]>)

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

fn faer_deref<T>( group: <Self::Group as ForType>::FaerOf<&T>, ) -> <Self::Group as ForType>::FaerOf<T>
where T: Copy,

fn faer_rb<'short, T>( value: <Self::Group as ForType>::FaerOf<&'short T>, ) -> <Self::Group as ForType>::FaerOf<<T as Reborrow<'short>>::Target>
where T: Reborrow<'short>,

fn faer_rb_mut<'short, T>( value: <Self::Group as ForType>::FaerOf<&'short mut T>, ) -> <Self::Group as ForType>::FaerOf<<T as ReborrowMut<'short>>::Target>
where T: ReborrowMut<'short>,

fn faer_into_const<T>( value: <Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<<T as IntoConst>::Target>
where T: IntoConst,

fn faer_copy<T>( x: &<Self::Group as ForType>::FaerOf<T>, ) -> <Self::Group as ForType>::FaerOf<T>
where T: Copy,

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

§

impl Entity for f32

§

type Unit = f32

§

type Index = u32

§

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

§

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

§

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

§

type Group = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, f32, S, <S as Simd>::m32s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, f32, S, <S as Simd>::m32s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, f32, S, <S as Simd>::m32s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, f32, S, <S as Simd>::m32s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<f32 as Entity>::Group as ForType>::FaerOf<()> = ()

§

fn faer_first<T>(group: <<f32 as Entity>::Group as ForType>::FaerOf<T>) -> T

§

fn faer_from_units( group: <<f32 as Entity>::Group as ForType>::FaerOf<<f32 as Entity>::Unit>, ) -> f32

§

fn faer_into_units( self, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<<f32 as Entity>::Unit>

§

fn faer_as_ref<T>( group: &<<f32 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<&T>

§

fn faer_as_mut<T>( group: &mut <<f32 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<&mut T>

§

fn faer_as_ptr<T>( group: *mut <<f32 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<*mut T>

§

fn faer_map_impl<T, U>( group: <<f32 as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(T) -> U, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<U>

§

fn faer_map_with_context<Ctx, T, U>( ctx: Ctx, group: <<f32 as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(Ctx, T) -> (Ctx, U), ) -> (Ctx, <<f32 as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_zip<T, U>( first: <<f32 as Entity>::Group as ForType>::FaerOf<T>, second: <<f32 as Entity>::Group as ForType>::FaerOf<U>, ) -> <<f32 as Entity>::Group as ForType>::FaerOf<(T, U)>

§

fn faer_unzip<T, U>( zipped: <<f32 as Entity>::Group as ForType>::FaerOf<(T, U)>, ) -> (<<f32 as Entity>::Group as ForType>::FaerOf<T>, <<f32 as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_into_iter<I>( iter: <<f32 as Entity>::Group as ForType>::FaerOf<I>, ) -> <f32 as Entity>::Iter<<I as IntoIterator>::IntoIter>
where I: IntoIterator,

§

impl Entity for f64

§

type Unit = f64

§

type Index = u64

§

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

§

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

§

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

§

type Group = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, f64, S, <S as Simd>::m64s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, f64, S, <S as Simd>::m64s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, f64, S, <S as Simd>::m64s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, f64, S, <S as Simd>::m64s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<f64 as Entity>::Group as ForType>::FaerOf<()> = ()

§

fn faer_first<T>(group: <<f64 as Entity>::Group as ForType>::FaerOf<T>) -> T

§

fn faer_from_units( group: <<f64 as Entity>::Group as ForType>::FaerOf<<f64 as Entity>::Unit>, ) -> f64

§

fn faer_into_units( self, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<<f64 as Entity>::Unit>

§

fn faer_as_ref<T>( group: &<<f64 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<&T>

§

fn faer_as_mut<T>( group: &mut <<f64 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<&mut T>

§

fn faer_as_ptr<T>( group: *mut <<f64 as Entity>::Group as ForType>::FaerOf<T>, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<*mut T>

§

fn faer_map_impl<T, U>( group: <<f64 as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(T) -> U, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<U>

§

fn faer_map_with_context<Ctx, T, U>( ctx: Ctx, group: <<f64 as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(Ctx, T) -> (Ctx, U), ) -> (Ctx, <<f64 as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_zip<T, U>( first: <<f64 as Entity>::Group as ForType>::FaerOf<T>, second: <<f64 as Entity>::Group as ForType>::FaerOf<U>, ) -> <<f64 as Entity>::Group as ForType>::FaerOf<(T, U)>

§

fn faer_unzip<T, U>( zipped: <<f64 as Entity>::Group as ForType>::FaerOf<(T, U)>, ) -> (<<f64 as Entity>::Group as ForType>::FaerOf<T>, <<f64 as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_into_iter<I>( iter: <<f64 as Entity>::Group as ForType>::FaerOf<I>, ) -> <f64 as Entity>::Iter<<I as IntoIterator>::IntoIter>
where I: IntoIterator,

§

impl<E> Entity for Complex<E>
where E: Entity,

§

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

§

type Iter<I: Iterator> = ComplexIter<<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>

§

const N_COMPONENTS: usize = _

§

const UNIT: <<Complex<E> as Entity>::Group as ForType>::FaerOf<()> = _

§

fn faer_first<T>( group: <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, ) -> T

§

fn faer_from_units( group: <<Complex<E> as Entity>::Group as ForType>::FaerOf<<Complex<E> as Entity>::Unit>, ) -> Complex<E>

§

fn faer_into_units( self, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<<Complex<E> as Entity>::Unit>

§

fn faer_as_ref<T>( group: &<<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<&T>

§

fn faer_as_mut<T>( group: &mut <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<&mut T>

§

fn faer_as_ptr<T>( group: *mut <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<*mut T>

§

fn faer_map_impl<T, U>( group: <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(T) -> U, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<U>

§

fn faer_map_with_context<Ctx, T, U>( ctx: Ctx, group: <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, f: &mut impl FnMut(Ctx, T) -> (Ctx, U), ) -> (Ctx, <<Complex<E> as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_zip<T, U>( first: <<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, second: <<Complex<E> as Entity>::Group as ForType>::FaerOf<U>, ) -> <<Complex<E> as Entity>::Group as ForType>::FaerOf<(T, U)>

§

fn faer_unzip<T, U>( zipped: <<Complex<E> as Entity>::Group as ForType>::FaerOf<(T, U)>, ) -> (<<Complex<E> as Entity>::Group as ForType>::FaerOf<T>, <<Complex<E> as Entity>::Group as ForType>::FaerOf<U>)

§

fn faer_into_iter<I>( iter: <<Complex<E> as Entity>::Group as ForType>::FaerOf<I>, ) -> <Complex<E> as Entity>::Iter<<I as IntoIterator>::IntoIter>
where I: IntoIterator,

Implementors§

§

impl Entity for c32

§

type Unit = c32

§

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 = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, Complex<f32>, S, <S as Simd>::m32s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<c32 as Entity>::Group as ForCopyType>::FaerOfCopy<()> = ()

§

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 = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, Complex<f32>, S, <S as Simd>::m32s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, Complex<f32>, S, <S as Simd>::m32s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<c32conj as Entity>::Group as ForCopyType>::FaerOfCopy<()> = ()

§

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 = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, Complex<f64>, S, <S as Simd>::m64s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<c64 as Entity>::Group as ForCopyType>::FaerOfCopy<()> = ()

§

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 = IdentityGroup

§

type Iter<I: Iterator> = I

§

type PrefixUnit<'a, S: Simd> = Prefix<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type SuffixUnit<'a, S: Simd> = Suffix<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type PrefixMutUnit<'a, S: Simd> = PrefixMut<'a, Complex<f64>, S, <S as Simd>::m64s>

§

type SuffixMutUnit<'a, S: Simd> = SuffixMut<'a, Complex<f64>, S, <S as Simd>::m64s>

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<c64conj as Entity>::Group as ForCopyType>::FaerOfCopy<()> = ()

§

impl Entity for Symbolic

§

type Unit = Symbolic

§

type Index = usize

§

type SimdUnit<S: Simd> = Symbolic

§

type SimdMask<S: Simd> = bool

§

type SimdIndex<S: Simd> = usize

§

type Group = IdentityGroup

§

type Iter<I: Iterator> = I

§

const N_COMPONENTS: usize = 1usize

§

const UNIT: <<Symbolic as Entity>::Group as ForCopyType>::FaerOfCopy<()> = ()

§

type PrefixUnit<'a, S: Simd> = &'a [Symbolic]

§

type SuffixUnit<'a, S: Simd> = &'a [Symbolic]

§

type PrefixMutUnit<'a, S: Simd> = &'a mut [Symbolic]

§

type SuffixMutUnit<'a, S: Simd> = &'a mut [Symbolic]

§

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

§

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>

§

const N_COMPONENTS: usize = _

§

const UNIT: <<ComplexConj<E> as Entity>::Group as ForType>::FaerOf<()> = _