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 DeviceBaseAPI for DeviceCpuSerial

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

fn default_order(&self) -> FlagOrder

fn set_default_order(&mut self, order: FlagOrder)

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> 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> DeviceCreationArangeAPI<T> for DeviceCpuSerial

where T: PartialOrd + Clone + Add<Output = T> + Zero + 'static, 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> 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>>

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<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<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<T> DeviceRawAPI<T> for DeviceCpuSerial

type Raw = Vec<T>

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, DA, DB, DC> DeviceVecdotAPI<TA, TB, TC, DA, DB, DC> for DeviceCpuSerial

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

fn vecdot( &self, c: &mut Vec<MaybeUninit<TC>>, lc: &Layout<DC>, a: &Vec<TA>, la: &Layout<DA>, b: &Vec<TB>, lb: &Layout<DB>, axes_a: &[isize], axes_b: &[isize], ) -> Result<()>

impl<TA, TB, D> OpATan2API<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> OpAbsAPI<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> OpAcosAPI<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> OpAcoshAPI<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> OpAddAPI<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> OpAddAssignAPI<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<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<T, D> OpAsinAPI<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> OpAsinhAPI<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<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> OpAtanAPI<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> OpAtanhAPI<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> OpBitAndAPI<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> OpBitAndAssignAPI<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> OpBitOrAPI<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> OpBitOrAssignAPI<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> OpBitXorAPI<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> OpBitXorAssignAPI<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> OpCeilAPI<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> OpConjAPI<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> OpCopySignAPI<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> OpCosAPI<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> OpCoshAPI<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> 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<TA, TB, TC, D> OpDivAPI<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> OpDivAssignAPI<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> OpEqualAPI<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> OpExpAPI<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> OpExpm1API<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> OpFloorAPI<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> OpFloorDivideAPI<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> OpGreaterAPI<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> OpGreaterEqualAPI<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> OpHypotAPI<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> OpImagAPI<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> OpInvAPI<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> OpIsCloseAPI<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> OpIsFiniteAPI<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> OpIsInfAPI<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> OpIsNanAPI<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> 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<TA, TB, D> OpLConsumeAddAPI<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> OpLConsumeBitAndAPI<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> OpLConsumeBitOrAPI<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> OpLConsumeBitXorAPI<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> OpLConsumeDivAPI<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> OpLConsumeMulAPI<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> OpLConsumeRemAPI<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> OpLConsumeShlAPI<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> OpLConsumeShrAPI<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> OpLConsumeSubAPI<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> OpLessAPI<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> OpLessEqualAPI<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> OpLog10API<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> OpLog2API<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> OpLogAPI<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> OpLogAddExpAPI<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<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<TA, TB, D> OpMaximumAPI<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<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<TA, TB, D> OpMinimumAPI<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> OpMulAPI<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> OpMulAssignAPI<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> OpNegAPI<TA, TB, D> for DeviceCpuSerial

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

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

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

impl<TA, TB, D> OpNextAfterAPI<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> OpNotAPI<TA, TB, D> for DeviceCpuSerial

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

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

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

impl<T> OpPackTriAPI<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<TA, TB, D> OpPowAPI<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<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<TA, TB, D> OpRConsumeAddAPI<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> OpRConsumeBitAndAPI<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> OpRConsumeBitOrAPI<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> OpRConsumeBitXorAPI<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> OpRConsumeDivAPI<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> OpRConsumeMulAPI<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> OpRConsumeRemAPI<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> OpRConsumeShlAPI<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> OpRConsumeShrAPI<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> OpRConsumeSubAPI<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, D> OpRealAPI<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> OpReciprocalAPI<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> OpRemAPI<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> OpRemAssignAPI<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> OpRoundAPI<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> OpShlAPI<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> OpShlAssignAPI<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> OpShrAPI<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> OpShrAssignAPI<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> OpSignAPI<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> OpSignBitAPI<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> OpSinAPI<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> OpSinhAPI<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> OpSqrtAPI<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> OpSquareAPI<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, 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<TA, TB, TC, D> OpSubAPI<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> OpSubAssignAPI<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> 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> OpTanAPI<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> OpTanhAPI<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> OpTruncAPI<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> OpUnpackTriAPI<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> 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, D, F> Op_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> Op_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> Op_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> Op_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> Op_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> Op_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<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,