faer

Trait Entity

Source
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 3 associated constants and 22 methods const N_COMPONENTS: usize; const UNIT: <Self::Group as ForType>::FaerOf<()>; const IS_REAL: bool = true; // 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 Constants§

Provided Associated Constants§

Source

const IS_REAL: bool = true

Required Associated Types§

Source

type Group: ForType + ForCopyType + ForDebugType

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Required Methods§

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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>

Source

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)>

Source

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>)

Source

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>)

Source

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

Provided Methods§

Source

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

Source

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

Source

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

Source

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

Source

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]>)

Source

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]>)

Source

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

Source

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>,

Source

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>,

Source

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

Source

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

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl Entity for f32

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = f32

Source§

type Index = u32

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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>

Source§

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>)

Source§

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)>

Source§

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>)

Source§

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,

Source§

impl Entity for f64

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = f64

Source§

type Index = u64

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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>

Source§

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>)

Source§

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)>

Source§

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>)

Source§

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,

Source§

impl Entity for i8

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = i8

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = i8

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = i8

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for i16

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = i16

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = i16

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = i16

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for i32

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = i32

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = i32

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = i32

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for i64

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = i64

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = i64

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = i64

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for i128

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = i128

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = i128

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = i128

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for isize

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = isize

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = isize

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = isize

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for u8

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = u8

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = u8

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = u8

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for u16

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = u16

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = u16

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = u16

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for u32

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = u32

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = u32

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = u32

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for u64

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = u64

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = u64

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = u64

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for u128

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = u128

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = u128

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = u128

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for usize

Source§

const N_COMPONENTS: usize = 1usize

Source§

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

Source§

type Unit = usize

Source§

type Index = usize

Source§

type SimdUnit<S: Simd> = usize

Source§

type SimdMask<S: Simd> = bool

Source§

type SimdIndex<S: Simd> = usize

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

const IS_REAL: bool = false

Source§

const N_COMPONENTS: usize

Source§

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

Source§

type Unit = <E as Entity>::Unit

Source§

type Index = <E as Entity>::Index

Source§

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

Source§

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

Source§

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

Source§

type Group = ComplexGroup<<E as Entity>::Group>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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>

Source§

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>

Source§

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>

Source§

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>)

Source§

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)>

Source§

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>)

Source§

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§

Source§

impl Entity for c32

Source§

const IS_REAL: bool = false

Source§

const N_COMPONENTS: usize = 1usize

Source§

const UNIT: GroupCopyFor<Self, ()> = ()

Source§

type Unit = c32

Source§

type Index = u32

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for c32conj

Source§

const N_COMPONENTS: usize = 1usize

Source§

const UNIT: GroupCopyFor<Self, ()> = ()

Source§

type Unit = c32conj

Source§

type Index = u32

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for c64

Source§

const IS_REAL: bool = false

Source§

const N_COMPONENTS: usize = 1usize

Source§

const UNIT: GroupCopyFor<Self, ()> = ()

Source§

type Unit = c64

Source§

type Index = u64

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for c64conj

Source§

const N_COMPONENTS: usize = 1usize

Source§

const UNIT: GroupCopyFor<Self, ()> = ()

Source§

type Unit = c64conj

Source§

type Index = u64

Source§

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

Source§

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

Source§

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

Source§

type Group = IdentityGroup

Source§

type Iter<I: Iterator> = I

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl Entity for Symbolic

Source§

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

Source§

const N_COMPONENTS: usize

Source§

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

Source§

type Unit = <E as Entity>::Unit

Source§

type Index = <E as Entity>::Index

Source§

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

Source§

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

Source§

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

Source§

type Group = ComplexConjGroup<<E as Entity>::Group>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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