Struct DeviceCpuSerial 

pub struct DeviceCpuSerial { /* private fields */ }

Trait Implementations

impl Clone for DeviceCpuSerial

fn clone(&self) -> DeviceCpuSerial

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceCpuSerial

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

Formats the value using the given formatter.

impl Default for DeviceCpuSerial

fn default() -> DeviceCpuSerial

Returns the “default value” for a type.

impl<TA, TB, D> DeviceATan2API<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: DTypeIntoFloatAPI, <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType: Float, TB: Clone, D: DimAPI,

type TOut = <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceATan2API<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceATan2API<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceATan2API<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAbsAPI<T, D> for DeviceCpuSerial

where T: ExtNum, D: DimAPI,

type TOut = <T as ExtNum>::AbsOut

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAcosAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAcosAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAcosAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAcoshAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAcoshAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAcoshAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceAddAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Add<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceAddAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + AddAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<T, D> DeviceAsinAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAsinAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAsinAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAsinhAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAsinhAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAsinhAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAtanAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAtanAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAtanAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceAtanhAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAtanhAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceAtanhAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl DeviceBaseAPI for DeviceCpuSerial

fn same_device(&self, other: &DeviceCpuSerial) -> bool

fn default_order(&self) -> FlagOrder

fn set_default_order(&mut self, order: FlagOrder)

impl<TA, TB, TC, D> DeviceBitAndAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + BitAnd<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceBitAndAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitAndAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceBitOrAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + BitOr<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceBitOrAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitOrAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceBitXorAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + BitXor<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceBitXorAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitXorAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<T, D> DeviceCeilAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: Float, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCeilAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCeilAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceCpuSerial, R, T, D> for DeviceCpuSerial

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorBase<Storage<R, T, DeviceCpuSerial>, D>, device: &DeviceCpuSerial, ) -> Result<TensorBase<Storage<<DeviceCpuSerial as DeviceChangeAPI<'a, DeviceCpuSerial, R, T, D>>::Repr, T, DeviceCpuSerial>, D>, Error>

fn into_device( tensor: TensorBase<Storage<R, T, DeviceCpuSerial>, D>, device: &DeviceCpuSerial, ) -> Result<TensorBase<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, D>, Error>

fn to_device( tensor: &'a TensorBase<Storage<R, T, DeviceCpuSerial>, D>, device: &DeviceCpuSerial, ) -> Result<TensorBase<Storage<DataRef<'a, <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>, T, DeviceCpuSerial>, D>, Error>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceCpuSerial, R, T, D> for DeviceOpenBLAS

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<Self::Repr, T, DeviceCpuSerial, D>>

fn into_device( tensor: TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<DataOwned<Vec<T>>, T, DeviceCpuSerial, D>>

fn to_device( tensor: &'a TensorAny<R, T, DeviceBLAS, D>, device: &DeviceCpuSerial, ) -> Result<TensorView<'a, T, DeviceCpuSerial, D>>

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceOpenBLAS, R, T, D> for DeviceCpuSerial

where T: Clone + Send + Sync + 'a, D: DimAPI, R: DataCloneAPI<Data = Vec<T>>,

type Repr = R

type ReprTo = DataRef<'a, Vec<T>>

fn change_device( tensor: TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorAny<Self::Repr, T, DeviceBLAS, D>>

fn into_device( tensor: TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorAny<DataOwned<Vec<T>>, T, DeviceBLAS, D>>

fn to_device( tensor: &'a TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceBLAS, ) -> Result<TensorView<'a, T, DeviceBLAS, D>>

impl<T, D> DeviceConjAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceConjAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceConjAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceCopySignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: DTypeIntoFloatAPI, <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType: Float, TB: Clone, D: DimAPI,

type TOut = <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCopySignAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCopySignAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCopySignAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceCosAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCosAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCosAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceCoshAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCoshAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceCoshAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T> DeviceCreationAnyAPI<T> for DeviceCpuSerial

where DeviceCpuSerial: DeviceRawAPI<MaybeUninit<T>, Raw = Vec<T>, Raw = Vec<MaybeUninit<T>>> + DeviceRawAPI<T>,

unsafe fn empty_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

Safety

fn full_impl( &self, len: usize, fill: T, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

where T: Clone,

fn outof_cpu_vec( &self, vec: Vec<T>, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

fn from_cpu_vec( &self, vec: &[T], ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

where T: Clone,

fn uninit_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<MaybeUninit<T>>>, MaybeUninit<T>, DeviceCpuSerial>, Error>

where DeviceCpuSerial: DeviceRawAPI<MaybeUninit<T>>,

unsafe fn assume_init_impl( storage: Storage<DataOwned<Vec<MaybeUninit<T>>>, MaybeUninit<T>, DeviceCpuSerial>, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

where DeviceCpuSerial: DeviceRawAPI<MaybeUninit<T>>,

Safety

impl<T> DeviceCreationComplexFloatAPI<T> for DeviceCpuSerial

where T: ComplexFloat + Clone, DeviceCpuSerial: DeviceRawAPI<T, Raw = Vec<T>>,

fn linspace_impl( &self, start: T, end: T, n: usize, endpoint: bool, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

impl<T> DeviceCreationNumAPI<T> for DeviceCpuSerial

where T: Num + Clone, DeviceCpuSerial: DeviceRawAPI<T, Raw = Vec<T>>,

fn zeros_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

fn ones_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

fn arange_int_impl( &self, len: usize, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

impl<T> DeviceCreationPartialOrdNumAPI<T> for DeviceCpuSerial

where T: Num + PartialOrd + Clone, DeviceCpuSerial: DeviceRawAPI<T, Raw = Vec<T>>,

fn arange_impl( &self, start: T, end: T, step: T, ) -> Result<Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Error>

impl<T> DeviceCreationTriAPI<T> for DeviceCpuSerial

where T: Num + Clone,

fn tril_impl<D>( &self, raw: &mut Vec<T>, layout: &Layout<D>, k: isize, ) -> Result<(), Error>

where D: DimAPI,

fn triu_impl<D>( &self, raw: &mut Vec<T>, layout: &Layout<D>, k: isize, ) -> Result<(), Error>

where D: DimAPI,

impl<TA, TB, TC, D> DeviceDivAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Div<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceDivAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DivAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceEqualAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: PartialEq, TB: Clone, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceExpAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceExpAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceExpAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceExpm1API<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: Float, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceExpm1API<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceExpm1API<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceFloorAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: Float, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceFloorAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceFloorAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceFloorDivideAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: ExtReal, TB: Clone, D: DimAPI,

type TOut = <TA as DTypePromoteAPI<TB>>::Res

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceFloorDivideAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceFloorDivideAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceFloorDivideAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceGreaterAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: PartialOrd, TB: Clone, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceGreaterEqualAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: PartialOrd, TB: Clone, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceGreaterEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceHypotAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: DTypeIntoFloatAPI, <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType: Float, TB: Clone, D: DimAPI,

type TOut = <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceHypotAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceHypotAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceHypotAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceImagAPI<T, D> for DeviceCpuSerial

where T: ExtNum, D: DimAPI,

type TOut = <T as ExtNum>::AbsOut

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceIndexSelectAPI<T, D> for DeviceCpuSerial

where T: Clone, D: DimAPI + DimSmallerOneAPI, <D as DimSmallerOneAPI>::SmallerOne: DimAPI,

fn index_select( &self, c: &mut Vec<MaybeUninit<T>>, lc: &Layout<D>, a: &Vec<T>, la: &Layout<D>, axis: usize, indices: &[usize], ) -> Result<(), Error>

Index select on one axis.

impl<T, D> DeviceInvAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceInvAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceInvAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D, TE> DeviceIsCloseAPI<TA, TB, D, TE> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, TB: Clone, <TA as DTypePromoteAPI<TB>>::Res: ExtNum, <<TA as DTypePromoteAPI<TB>>::Res as ExtNum>::AbsOut: DTypeCastAPI<TE>, TE: ExtFloat + Add<Output = TE> + Mul<Output = TE> + PartialOrd + Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, out: &mut <DeviceCpuSerial as DeviceRawAPI<MaybeUninit<bool>>>::Raw, lout: &Layout<D>, a: &<DeviceCpuSerial as DeviceRawAPI<TA>>::Raw, la: &Layout<D>, b: &<DeviceCpuSerial as DeviceRawAPI<TB>>::Raw, lb: &Layout<D>, isclose_args: &IsCloseArgs<TE>, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, out: &mut <DeviceCpuSerial as DeviceRawAPI<MaybeUninit<bool>>>::Raw, lout: &Layout<D>, a: TA, b: &<DeviceCpuSerial as DeviceRawAPI<TB>>::Raw, lb: &Layout<D>, isclose_args: &IsCloseArgs<TE>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, out: &mut <DeviceCpuSerial as DeviceRawAPI<MaybeUninit<bool>>>::Raw, lout: &Layout<D>, a: &<DeviceCpuSerial as DeviceRawAPI<TA>>::Raw, la: &Layout<D>, b: TB, isclose_args: &IsCloseArgs<TE>, ) -> Result<(), Error>

impl<T, D> DeviceIsFiniteAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<bool>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, _a: &mut Vec<MaybeUninit<bool>>, _la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceIsInfAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<bool>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, _a: &mut Vec<MaybeUninit<bool>>, _la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceIsNanAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<bool>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, _a: &mut Vec<MaybeUninit<bool>>, _la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeAddAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Add<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeBitAndAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitAnd<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeBitOrAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitOr<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeBitXorAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitXor<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeDivAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Div<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeMulAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Mul<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeRemAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Rem<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeShlAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Shl<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeShrAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Shr<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLConsumeSubAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Sub<TB, Output = TA>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLessAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: PartialOrd, TB: Clone, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLessEqualAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: PartialOrd, TB: Clone, D: DimAPI,

type TOut = bool

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLessEqualAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceLog10API<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLog10API<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLog10API<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceLog2API<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLog2API<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLog2API<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceLogAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLogAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLogAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceLogAddExpAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: DTypeIntoFloatAPI, <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType: ComplexFloat, TB: Clone, D: DimAPI,

type TOut = <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLogAddExpAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLogAddExpAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceLogAddExpAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, TC, DA, DB, DC> DeviceMatMulAPI<TA, TB, TC, DA, DB, DC> for DeviceCpuSerial

where TB: Clone + Mul<TA, Output = TC>, TC: Clone + Mul<Output = TC> + Add<Output = TC>, DA: DimAPI, DB: DimAPI, DC: DimAPI, TA: Mul<TB, Output = TC> + Clone, DeviceCpuSerial: DeviceAPI<TA, Raw = Vec<TA>, Raw = Vec<TB>, Raw = Vec<TC>> + DeviceAPI<TB> + DeviceAPI<TC>,

fn matmul( &self, c: &mut Vec<TC>, lc: &Layout<DC>, a: &Vec<TA>, la: &Layout<DA>, b: &Vec<TB>, lb: &Layout<DB>, alpha: TC, beta: TC, ) -> Result<(), Error>

impl<TA, TB, D> DeviceMaximumAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: ExtReal, TB: Clone, D: DimAPI,

type TOut = <TA as DTypePromoteAPI<TB>>::Res

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMaximumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMaximumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMaximumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceMinimumAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: ExtReal, TB: Clone, D: DimAPI,

type TOut = <TA as DTypePromoteAPI<TB>>::Res

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMinimumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMinimumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceMinimumAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceMulAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Mul<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceMulAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + MulAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, D> DeviceNegAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<TA>>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

where TB: Neg<Output = TA>,

fn op_muta(&self, a: &mut Vec<TA>, la: &Layout<D>) -> Result<(), Error>

where TA: Neg<Output = TA>,

impl<TA, TB, D> DeviceNextAfterAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, <TA as DTypePromoteAPI<TB>>::Res: DTypeIntoFloatAPI, <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType: ExtFloat, TB: Clone, D: DimAPI,

type TOut = <<TA as DTypePromoteAPI<TB>>::Res as DTypeIntoFloatAPI>::FloatType

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceNextAfterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceNextAfterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceNextAfterAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceNotAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<TA>>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

where TB: Not<Output = TA>,

fn op_muta(&self, a: &mut Vec<TA>, la: &Layout<D>) -> Result<(), Error>

where TA: Not<Output = TA>,

impl<T> DeviceOpPackTriAPI<T> for DeviceCpuSerial

where T: Clone,

fn pack_tri( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<Vec<usize>>, b: &Vec<T>, lb: &Layout<Vec<usize>>, uplo: FlagUpLo, ) -> Result<(), Error>

impl<T> DeviceOpUnpackTriAPI<T> for DeviceCpuSerial

where T: ComplexFloat,

fn unpack_tri( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<Vec<usize>>, b: &Vec<T>, lb: &Layout<Vec<usize>>, uplo: FlagUpLo, symm: FlagSymm, ) -> Result<(), Error>

impl<T, D, F> DeviceOp_MutA_API<T, D, F> for DeviceCpuSerial

where T: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<T>) + ?Sized,

fn op_muta_func( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<D>, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, D, F> DeviceOp_MutA_NumB_API<TA, TB, D, F> for DeviceCpuSerial

where TA: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<TA>, &TB) + ?Sized,

fn op_muta_numb_func( &self, a: &mut Vec<MaybeUninit<TA>>, la: &Layout<D>, b: TB, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, D, F> DeviceOp_MutA_RefB_API<TA, TB, D, F> for DeviceCpuSerial

where TA: Clone, TB: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<TA>, &TB) + ?Sized,

fn op_muta_refb_func( &self, a: &mut Vec<MaybeUninit<TA>>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, TC, D, F> DeviceOp_MutC_NumA_RefB_API<TA, TB, TC, D, F> for DeviceCpuSerial

where TB: Clone, TC: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<TC>, &TA, &TB) + ?Sized,

fn op_mutc_numa_refb_func( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, TC, D, F> DeviceOp_MutC_RefA_NumB_API<TA, TB, TC, D, F> for DeviceCpuSerial

where TA: Clone, TC: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<TC>, &TA, &TB) + ?Sized,

fn op_mutc_refa_numb_func( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, TC, D, F> DeviceOp_MutC_RefA_RefB_API<TA, TB, TC, D, F> for DeviceCpuSerial

where TA: Clone, TB: Clone, TC: Clone, D: DimAPI, F: FnMut(&mut MaybeUninit<TC>, &TA, &TB) + ?Sized,

fn op_mutc_refa_refb_func( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, f: &mut F, ) -> Result<(), Error>

impl<TA, TB, D> DevicePowAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Pow<TB>, TB: Clone, <TA as Pow<TB>>::Output: Clone, D: DimAPI,

type TOut = <TA as Pow<TB>>::Output

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<<DeviceCpuSerial as DevicePowAPI<TA, TB, D>>::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut <DeviceCpuSerial as DeviceRawAPI<MaybeUninit<<DeviceCpuSerial as DevicePowAPI<TA, TB, D>>::TOut>>>::Raw, lc: &Layout<D>, a: &<DeviceCpuSerial as DeviceRawAPI<TA>>::Raw, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut <DeviceCpuSerial as DeviceRawAPI<MaybeUninit<<DeviceCpuSerial as DevicePowAPI<TA, TB, D>>::TOut>>>::Raw, lc: &Layout<D>, a: TA, b: &<DeviceCpuSerial as DeviceRawAPI<TB>>::Raw, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeAddAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Add<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeBitAndAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitAnd<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeBitOrAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitOr<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeBitXorAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + BitXor<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeDivAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Div<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeMulAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Mul<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeRemAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Rem<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeShlAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Shl<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeShrAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Shr<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRConsumeSubAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + Sub<TB, Output = TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, b: &mut Vec<TB>, lb: &Layout<D>, a: TA, ) -> Result<(), Error>

impl<T> DeviceRawAPI<T> for DeviceCpuSerial

type Raw = Vec<T>

impl<T, D> DeviceRealAPI<T, D> for DeviceCpuSerial

where T: ExtNum, D: DimAPI,

type TOut = <T as ExtNum>::AbsOut

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, _a: &mut Vec<MaybeUninit<<T as ExtNum>::AbsOut>>, _la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceReciprocalAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceReciprocalAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceReciprocalAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceRemAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Rem<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceRemAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + RemAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<T, D> DeviceRoundAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: Float, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceRoundAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceRoundAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceShlAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Shl<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceShlAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + ShlAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<TA, TB, TC, D> DeviceShrAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Shr<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceShrAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + ShrAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<T, D> DeviceSignAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat<Output = T> + Div<<T as ComplexFloat>::Real>, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceSignBitAPI<T, D> for DeviceCpuSerial

where T: Clone + Signed, D: DimAPI,

type TOut = bool

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<bool>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, _a: &mut Vec<MaybeUninit<bool>>, _la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceSinAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSinAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSinAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceSinhAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSinhAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSinhAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceSqrtAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSqrtAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceSqrtAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceSquareAPI<T, D> for DeviceCpuSerial

where T: Clone + Mul<Output = T>, D: DimAPI,

type TOut = T

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<T>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T> DeviceStorageAPI<T> for DeviceCpuSerial

fn len<R>(storage: &Storage<R, T, DeviceCpuSerial>) -> usize

where R: DataAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn to_cpu_vec<R>( storage: &Storage<R, T, DeviceCpuSerial>, ) -> Result<Vec<T>, Error>

where <DeviceCpuSerial as DeviceRawAPI<T>>::Raw: Clone, R: DataAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn into_cpu_vec<R>( storage: Storage<R, T, DeviceCpuSerial>, ) -> Result<Vec<T>, Error>

where <DeviceCpuSerial as DeviceRawAPI<T>>::Raw: Clone, R: DataCloneAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn get_index<R>(storage: &Storage<R, T, DeviceCpuSerial>, index: usize) -> T

where T: Clone, R: DataAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn get_index_ptr<R>( storage: &Storage<R, T, DeviceCpuSerial>, index: usize, ) -> *const T

where R: DataAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn get_index_mut_ptr<R>( storage: &mut Storage<R, T, DeviceCpuSerial>, index: usize, ) -> *mut T

where R: DataMutAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn set_index<R>( storage: &mut Storage<R, T, DeviceCpuSerial>, index: usize, value: T, )

where R: DataMutAPI<Data = <DeviceCpuSerial as DeviceRawAPI<T>>::Raw>,

fn is_empty<R>(storage: &Storage<R, T, Self>) -> bool

where R: DataAPI<Data = Self::Raw>,

impl<TA, TB, TC, D> DeviceSubAPI<TA, TB, TC, D> for DeviceCpuSerial

where TA: Clone + Sub<TB, Output = TC>, TB: Clone, TC: Clone, D: DimAPI,

fn op_mutc_refa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_mutc_refa_numb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

fn op_mutc_numa_refb( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: TA, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

impl<TA, TB, D> DeviceSubAssignAPI<TA, TB, D> for DeviceCpuSerial

where TA: Clone + SubAssign<TB>, TB: Clone, D: DimAPI,

fn op_muta_refb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta_numb( &self, a: &mut Vec<TA>, la: &Layout<D>, b: TB, ) -> Result<(), Error>

impl<T, D> DeviceTanAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTanAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTanAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceTanhAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: ComplexFloat, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTanhAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTanhAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<T, D> DeviceTruncAPI<T, D> for DeviceCpuSerial

where T: Clone + DTypeIntoFloatAPI, <T as DTypeIntoFloatAPI>::FloatType: Float, D: DimAPI,

type TOut = <T as DTypeIntoFloatAPI>::FloatType

fn op_muta_refb( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTruncAPI<T, D>>::TOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<(), Error>

fn op_muta( &self, a: &mut Vec<MaybeUninit<<DeviceCpuSerial as DeviceTruncAPI<T, D>>::TOut>>, la: &Layout<D>, ) -> Result<(), Error>

impl<D> OpAllAPI<bool, D> for DeviceCpuSerial

where D: DimAPI,

type TOut = bool

fn all_all(&self, a: &Vec<bool>, la: &Layout<D>) -> Result<bool, Error>

fn all_axes( &self, a: &Vec<bool>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<bool>>, bool, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<TA, TB, TE, D> OpAllCloseAPI<TA, TB, TE, D> for DeviceCpuSerial

where TA: Clone + DTypePromoteAPI<TB>, TB: Clone, <TA as DTypePromoteAPI<TB>>::Res: ExtNum, <<TA as DTypePromoteAPI<TB>>::Res as ExtNum>::AbsOut: DTypeCastAPI<TE>, TE: ExtFloat + Add<Output = TE> + Mul<Output = TE> + PartialOrd + Clone, D: DimAPI,

fn allclose_all( &self, a: &<DeviceCpuSerial as DeviceRawAPI<TA>>::Raw, la: &Layout<D>, b: &<DeviceCpuSerial as DeviceRawAPI<TB>>::Raw, lb: &Layout<D>, isclose_args: &IsCloseArgs<TE>, ) -> Result<bool, Error>

fn allclose_axes( &self, _a: &<DeviceCpuSerial as DeviceRawAPI<TA>>::Raw, _la: &Layout<D>, _b: &<DeviceCpuSerial as DeviceRawAPI<TB>>::Raw, _lb: &Layout<D>, _axes: &[isize], _isclose_args: &IsCloseArgs<TE>, ) -> Result<(Storage<DataOwned<<DeviceCpuSerial as DeviceRawAPI<bool>>::Raw>, bool, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<D> OpAnyAPI<bool, D> for DeviceCpuSerial

where D: DimAPI,

type TOut = bool

fn any_all(&self, a: &Vec<bool>, la: &Layout<D>) -> Result<bool, Error>

fn any_axes( &self, a: &Vec<bool>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<bool>>, bool, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpArgMaxAPI<T, D> for DeviceCpuSerial

where T: Clone + PartialOrd, D: DimAPI,

type TOut = usize

fn argmax_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, <DeviceCpuSerial as OpArgMaxAPI<T, D>>::TOut, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

fn argmax_all( &self, a: &Vec<T>, la: &Layout<D>, ) -> Result<<DeviceCpuSerial as OpArgMaxAPI<T, D>>::TOut, Error>

impl<T, D> OpArgMinAPI<T, D> for DeviceCpuSerial

where T: Clone + PartialOrd, D: DimAPI,

type TOut = usize

fn argmin_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, <DeviceCpuSerial as OpArgMinAPI<T, D>>::TOut, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

fn argmin_all( &self, a: &Vec<T>, la: &Layout<D>, ) -> Result<<DeviceCpuSerial as OpArgMinAPI<T, D>>::TOut, Error>

impl<TC, D, TA> OpAssignAPI<TC, D, TA> for DeviceCpuSerial

where TC: Clone, TA: Clone + DTypeCastAPI<TC>, D: DimAPI,

fn assign( &self, c: &mut Vec<TC>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

Element-wise assignment for same layout arrays.

fn assign_uninit( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, ) -> Result<(), Error>

fn fill(&self, c: &mut Vec<TC>, lc: &Layout<D>, fill: TA) -> Result<(), Error>

impl<TC, DC, DA, TA> OpAssignArbitaryAPI<TC, DC, DA, TA> for DeviceCpuSerial

where TC: Clone, TA: Clone + DTypeCastAPI<TC>, DC: DimAPI, DA: DimAPI,

fn assign_arbitary( &self, c: &mut Vec<TC>, lc: &Layout<DC>, a: &Vec<TA>, la: &Layout<DA>, ) -> Result<(), Error>

Element-wise assignment in col-major order, without no promise that input layouts are broadcastable.

fn assign_arbitary_uninit( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<DC>, a: &Vec<TA>, la: &Layout<DA>, ) -> Result<(), Error>

impl<T, D> OpCountNonZeroAPI<T, D> for DeviceCpuSerial

where T: Clone + PartialEq + Zero, D: DimAPI,

type TOut = usize

fn count_nonzero_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<usize, Error>

fn count_nonzero_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, usize, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpL2NormAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat + FromPrimitive, <T as ComplexFloat>::Real: Clone + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn l2_norm_all( &self, a: &Vec<T>, la: &Layout<D>, ) -> Result<<T as ComplexFloat>::Real, Error>

fn l2_norm_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<<T as ComplexFloat>::Real>>, <T as ComplexFloat>::Real, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpMaxAPI<T, D> for DeviceCpuSerial

where T: ExtReal, D: DimAPI,

type TOut = T

fn max_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T, Error>

fn max_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpMeanAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = T

fn mean_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T, Error>

fn mean_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpMinAPI<T, D> for DeviceCpuSerial

where T: ExtReal, D: DimAPI,

type TOut = T

fn min_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T, Error>

fn min_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpProdAPI<T, D> for DeviceCpuSerial

where T: Clone + One<Output = T> + Mul, D: DimAPI,

type TOut = T

fn prod_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T, Error>

fn prod_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpStdAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat + FromPrimitive, <T as ComplexFloat>::Real: Clone + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn std_all( &self, a: &Vec<T>, la: &Layout<D>, ) -> Result<<T as ComplexFloat>::Real, Error>

fn std_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<<T as ComplexFloat>::Real>>, <T as ComplexFloat>::Real, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpSumAPI<T, D> for DeviceCpuSerial

where T: Zero<Output = T> + Add + Clone, D: DimAPI,

type TOut = T

fn sum_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<T, Error>

fn sum_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T>>, T, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<D> OpSumBoolAPI<D> for DeviceCpuSerial

where D: DimAPI,

fn sum_all(&self, a: &Vec<bool>, la: &Layout<D>) -> Result<usize, Error>

fn sum_axes( &self, a: &Vec<bool>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<usize>>, usize, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T, D> OpUnraveledArgMaxAPI<T, D> for DeviceCpuSerial

where T: Clone + PartialOrd, D: DimAPI,

fn unraveled_argmax_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<Vec<usize>>>, Vec<usize>, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

fn unraveled_argmax_all( &self, a: &<DeviceCpuSerial as DeviceRawAPI<T>>::Raw, la: &Layout<D>, ) -> Result<D, Error>

impl<T, D> OpUnraveledArgMinAPI<T, D> for DeviceCpuSerial

where T: Clone + PartialOrd, D: DimAPI,

fn unraveled_argmin_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<Vec<usize>>>, Vec<usize>, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

fn unraveled_argmin_all( &self, a: &<DeviceCpuSerial as DeviceRawAPI<T>>::Raw, la: &Layout<D>, ) -> Result<D, Error>

impl<T, D> OpVarAPI<T, D> for DeviceCpuSerial

where T: Clone + ComplexFloat + FromPrimitive, <T as ComplexFloat>::Real: Clone + ComplexFloat + FromPrimitive, D: DimAPI,

type TOut = <T as ComplexFloat>::Real

fn var_all( &self, a: &Vec<T>, la: &Layout<D>, ) -> Result<<T as ComplexFloat>::Real, Error>

fn var_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<<T as ComplexFloat>::Real>>, <T as ComplexFloat>::Real, DeviceCpuSerial>, Layout<Vec<usize>>), Error>

impl<T> DeviceAPI<T> for DeviceCpuSerial

impl<T, D> DeviceComplexFloatAPI<T, D> for DeviceCpuSerial

where T: ComplexFloat + DTypeIntoFloatAPI<FloatType = T>, <T as ComplexFloat>::Real: DTypeIntoFloatAPI<FloatType = <T as ComplexFloat>::Real>, D: DimAPI,

impl<T, D> DeviceNumAPI<T, D> for DeviceCpuSerial

where T: Clone + Num, D: DimAPI,