Struct DeviceCpuSerial 

pub struct DeviceCpuSerial {
    default_order: FlagOrder,
}

Fields

default_order: FlagOrder

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

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, Res: 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

impl DeviceBaseAPI for DeviceCpuSerial

fn same_device(&self, other: &Self) -> 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<()>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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: TensorAny<R, T, DeviceCpuSerial, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<Self::Repr, T, DeviceCpuSerial, D>>

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

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

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

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, DeviceFaer, D>, device: &DeviceCpuSerial, ) -> Result<TensorAny<Self::Repr, T, DeviceCpuSerial, D>>

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

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

impl<'a, R, T, D> DeviceChangeAPI<'a, DeviceFaer, 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: &DeviceFaer, ) -> Result<TensorAny<Self::Repr, T, DeviceFaer, D>>

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

where TA: Clone + DTypePromoteAPI<TB, Res: 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

impl<T> DeviceCreationAnyAPI<T> for DeviceCpuSerial

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

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

Safety

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

where T: Clone,

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

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

where T: Clone,

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

where Self: DeviceRawAPI<MaybeUninit<T>>,

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

where Self: 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>>

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

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

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

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

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

where D: DimAPI,

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

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

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

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

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

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

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

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

type TOut = bool

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

where TA: Clone + 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

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

type TOut = bool

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

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

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

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

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

type TOut = bool

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

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

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

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

where TA: Clone + DTypePromoteAPI<TB, Res: 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

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

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

where T: Clone, D: DimAPI + DimSmallerOneAPI, D::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<()>

Index select on one axis.

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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<AbsOut: DTypeCastAPI<TE>>, TE: ExtFloat + Add<TE, Output = TE> + Mul<TE, Output = TE> + PartialOrd + Clone, D: DimAPI,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type TOut = bool

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

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

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

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

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

type TOut = bool

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

where TA: Clone + DTypePromoteAPI<TB, Res: 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

where TA: Clone + Mul<TB, Output = TC>, TB: Clone + Mul<TA, Output = TC>, TC: Clone + Mul<TC, Output = TC> + Add<TC, Output = TC>, DA: DimAPI, DB: DimAPI, DC: DimAPI, Self: DeviceAPI<TA, Raw = Vec<TA>> + DeviceAPI<TB, Raw = Vec<TB>> + DeviceAPI<TC, Raw = Vec<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<()>

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

where TA: Clone + 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

where TA: Clone + 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

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

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

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

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

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

where TB: Neg<Output = TA>,

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

where TA: Neg<Output = TA>,

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

where TA: Clone + DTypePromoteAPI<TB, Res: 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<Self::TOut>>, lc: &Layout<D>, a: &Vec<TA>, la: &Layout<D>, b: &Vec<TB>, lb: &Layout<D>, ) -> Result<()>

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

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

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

where TB: Not<Output = TA>,

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

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<IxD>, b: &Vec<T>, lb: &Layout<IxD>, uplo: FlagUpLo, ) -> Result<()>

impl<T> DeviceOpUnpackTriAPI<T> for DeviceCpuSerial

where T: ComplexFloat,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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::AbsOut>>, la: &Layout<D>, b: &Vec<T>, lb: &Layout<D>, ) -> Result<()>

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

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

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

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

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

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

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

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

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

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

where T: Clone + ComplexFloat + Div<T::Real, 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<()>

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

impl<T> DeviceStorageAPI<T> for DeviceCpuSerial

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

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

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

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

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

where Self::Raw: Clone, R: DataCloneAPI<Data = Self::Raw>,

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

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

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

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

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

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

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

where R: DataMutAPI<Data = Self::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<()>

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

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

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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

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

type TOut = <T as DTypeIntoFloatAPI>::FloatType

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

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

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>

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

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<AbsOut: DTypeCastAPI<TE>>, TE: ExtFloat + Add<TE, Output = TE> + Mul<TE, Output = TE> + PartialOrd + Clone, D: DimAPI,

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

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

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>

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

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>>, Self::TOut, Self>, Layout<IxD>)>

fn argmax_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<Self::TOut>

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>>, Self::TOut, Self>, Layout<IxD>)>

fn argmin_all(&self, a: &Vec<T>, la: &Layout<D>) -> Result<Self::TOut>

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

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

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

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

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

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>

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

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

where T: Clone + ComplexFloat + FromPrimitive, T::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::Real>

fn l2_norm_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

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>

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

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>

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

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>

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

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

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

type TOut = T

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

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

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

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

type TOut = <T as ComplexFloat>::Real

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

fn std_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

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

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

type TOut = T

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

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

impl<D> OpSumBoolAPI<D> for DeviceCpuSerial

where D: DimAPI,

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

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

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<IxD>>, IxD, Self>, Layout<IxD>)>

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

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<IxD>>, IxD, Self>, Layout<IxD>)>

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

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

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

type TOut = <T as ComplexFloat>::Real

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

fn var_axes( &self, a: &Vec<T>, la: &Layout<D>, axes: &[isize], ) -> Result<(Storage<DataOwned<Vec<T::Real>>, T::Real, Self>, Layout<IxD>)>

impl<T> DeviceAPI<T> for DeviceCpuSerial

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

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

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

where T: Clone + Num, D: DimAPI,