Struct dfdx::devices::Cpu

pub struct Cpu;

The CPU device

Trait Implementations

impl AllocateZeros for Cpu

fn zeros<T: CountElements>() -> Box<T>

Allocates using alloc_zeroed.

impl<L: CountElements, R: CountElements, const M: usize> BroadcastForEach<[L; M], [R; M]> for Cpu where
    Self: BroadcastForEach<L, R>, 

fn foreach_mb<F>(l: &mut [L; M], r: Broadcast<'_, [R; M]>, f: &mut F) where
    F: FnMut(&mut L::Dtype, &R::Dtype), 

Applies f to each element of l and r, where r is broadcasted to be the same size as l.

fn foreach_mrb<F>(
    out: &mut [L; M],
    l: &[L; M],
    r: Broadcast<'_, [R; M]>,
    f: &mut F
) where
    F: FnMut(&mut L::Dtype, &L::Dtype, &R::Dtype), 

Applies f to each element of out, l, and r, where r is broadcasted to be the same size as out and l.

fn foreach_brr<F>(out: BroadcastMut<'_, [R; M]>, l: &[L; M], r: &[L; M], f: &mut F) where
    F: FnMut(&mut R::Dtype, &L::Dtype, &L::Dtype), 

Applies f to each element of out, l, and r, where out is broadcasted to be the same size as l and r.

impl<const M: usize> BroadcastForEach<[f32; M], f32> for Cpu

fn foreach_mb<F>(l: &mut [f32; M], r: Broadcast<'_, f32>, f: &mut F) where
    F: FnMut(&mut f32, &f32), 

Applies f to each element of l and r, where r is broadcasted to be the same size as l.

fn foreach_mrb<F>(
    out: &mut [f32; M],
    l: &[f32; M],
    r: Broadcast<'_, f32>,
    f: &mut F
) where
    F: FnMut(&mut f32, &f32, &f32), 

Applies f to each element of out, l, and r, where r is broadcasted to be the same size as out and l.

fn foreach_brr<F>(
    out: BroadcastMut<'_, f32>,
    l: &[f32; M],
    r: &[f32; M],
    f: &mut F
) where
    F: FnMut(&mut f32, &f32, &f32), 

Applies f to each element of out, l, and r, where out is broadcasted to be the same size as l and r.

impl BroadcastForEach<f32, f32> for Cpu

fn foreach_mb<F>(l: &mut f32, r: Broadcast<'_, f32>, f: &mut F) where
    F: FnMut(&mut f32, &f32), 

Applies f to each element of l and r, where r is broadcasted to be the same size as l.

fn foreach_mrb<F>(out: &mut f32, l: &f32, r: Broadcast<'_, f32>, f: &mut F) where
    F: FnMut(&mut f32, &f32, &f32), 

Applies f to each element of out, l, and r, where r is broadcasted to be the same size as out and l.

fn foreach_brr<F>(out: BroadcastMut<'_, f32>, l: &f32, r: &f32, f: &mut F) where
    F: FnMut(&mut f32, &f32, &f32), 

Applies f to each element of out, l, and r, where out is broadcasted to be the same size as l and r.

impl<T: CountElements, const M: usize> Device<[T; M]> for Cpu where
    Cpu: Device<T> + ReduceLastDim<[T; M]> + BroadcastForEach<[T; M], <Self as ReduceLastDim<[T; M]>>::Reduced>, 

fn map<F: FnMut(&T::Dtype) -> T::Dtype>(t: &T, f: F) -> Box<T>

Allocate a new T and then store f applied to t in the new T. Uses ForEachElement::foreach_mr.

fn add(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> AddAssign<&'r T::Dtype> + Copy, 

Computes lhs += rhs, using ForEachElement::foreach_mr.

fn badd(lhs: &mut T, rhs: Broadcast<'_, <Self as ReduceLastDim<T>>::Reduced>) where
    T::Dtype: for<'r> AddAssign<&'r T::Dtype> + Copy, 

Computes lhs += rhs, where rhs’s last dimension is broadcasted. Uses BroadcastForEach::foreach_mb

fn sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

fn bsub(lhs: &mut T, rhs: Broadcast<'_, <Self as ReduceLastDim<T>>::Reduced>) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs, where rhs’s last dimension is broadcasted. Uses BroadcastForEach::foreach_mb

fn addmul(out: &mut T, lhs: &T, rhs: &T) where
    T::Dtype: AddAssign,
    for<'r> &'r T::Dtype: Mul<Output = T::Dtype>, 

Computes out += lhs * rhs using ForEachElement::foreach_mrr.

impl Device<f32> for Cpu

fn map<F: FnMut(&T::Dtype) -> T::Dtype>(t: &T, f: F) -> Box<T>

Allocate a new T and then store f applied to t in the new T. Uses ForEachElement::foreach_mr.

fn add(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> AddAssign<&'r T::Dtype> + Copy, 

Computes lhs += rhs, using ForEachElement::foreach_mr.

fn badd(lhs: &mut T, rhs: Broadcast<'_, <Self as ReduceLastDim<T>>::Reduced>) where
    T::Dtype: for<'r> AddAssign<&'r T::Dtype> + Copy, 

Computes lhs += rhs, where rhs’s last dimension is broadcasted. Uses BroadcastForEach::foreach_mb

fn sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

fn bsub(lhs: &mut T, rhs: Broadcast<'_, <Self as ReduceLastDim<T>>::Reduced>) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs, where rhs’s last dimension is broadcasted. Uses BroadcastForEach::foreach_mb

fn addmul(out: &mut T, lhs: &T, rhs: &T) where
    T::Dtype: AddAssign,
    for<'r> &'r T::Dtype: Mul<Output = T::Dtype>, 

Computes out += lhs * rhs using ForEachElement::foreach_mrr.

impl<T: CountElements, const M: usize> FillElements<[T; M]> for Cpu where
    Self: FillElements<T>, 

fn fill<F: FnMut(&mut T::Dtype)>(out: &mut [T; M], f: &mut F)

fn filled<F: FnMut(&mut T::Dtype)>(f: &mut F) -> Box<T>

impl FillElements<f32> for Cpu

fn fill<F: FnMut(&mut f32)>(out: &mut f32, f: &mut F)

fn filled<F: FnMut(&mut T::Dtype)>(f: &mut F) -> Box<T>

impl<T: CountElements, const M: usize> ForEachElement<[T; M]> for Cpu where
    Self: ForEachElement<T>, 

fn foreach_m<F: FnMut(&mut <[T; M] as CountElements>::Dtype)>(
    a: &mut [T; M],
    f: &mut F
)

Mutate elements of a by applying f to all elements of a.

fn foreach_mm<F>(a: &mut [T; M], b: &mut [T; M], f: &mut F) where
    F: FnMut(&mut T::Dtype, &mut T::Dtype), 

Mutate elements of a and b by applying f to all elements of (a, b). mm stands for mut mut

fn foreach_mr<F>(a: &mut [T; M], b: &[T; M], f: &mut F) where
    F: FnMut(&mut T::Dtype, &T::Dtype), 

Mutate elements of a by applying f to all elements of (a, b). mr stands for mut ref

fn foreach_mmm<F>(a: &mut [T; M], b: &mut [T; M], c: &mut [T; M], f: &mut F) where
    F: FnMut(&mut T::Dtype, &mut T::Dtype, &mut T::Dtype), 

Mutate elements of a, b, and c by applying f to all elements of (a, b, c). mmm stands for mut mut mut

fn foreach_mrr<F>(a: &mut [T; M], b: &[T; M], c: &[T; M], f: &mut F) where
    F: FnMut(&mut T::Dtype, &T::Dtype, &T::Dtype), 

Mutate elements of a by applying f to all elements of (a, b, c). mrr stands for mut ref ref

impl ForEachElement<f32> for Cpu

fn foreach_m<F: FnMut(&mut <f32 as CountElements>::Dtype)>(
    a: &mut f32,
    f: &mut F
)

Mutate elements of a by applying f to all elements of a.

fn foreach_mm<F: FnMut(&mut f32, &mut f32)>(a: &mut f32, b: &mut f32, f: &mut F)

Mutate elements of a and b by applying f to all elements of (a, b). mm stands for mut mut

fn foreach_mr<F: FnMut(&mut f32, &f32)>(a: &mut f32, b: &f32, f: &mut F)

Mutate elements of a by applying f to all elements of (a, b). mr stands for mut ref

fn foreach_mmm<F>(a: &mut f32, b: &mut f32, c: &mut f32, f: &mut F) where
    F: FnMut(&mut f32, &mut f32, &mut f32), 

Mutate elements of a, b, and c by applying f to all elements of (a, b, c). mmm stands for mut mut mut

fn foreach_mrr<F>(a: &mut f32, b: &f32, c: &f32, f: &mut F) where
    F: FnMut(&mut f32, &f32, &f32), 

Mutate elements of a by applying f to all elements of (a, b, c). mrr stands for mut ref ref

impl<O: CountElements, L: CountElements + MultiDimensional, R: CountElements, const M: usize> ForEachLast<[O; M], [L; M], [R; M]> for Cpu where
    Cpu: ForEachLast<O, L, R>, 

fn foreachlast_mb<F>(l: &mut [L; M], r: Broadcast<'_, [R; M]>, f: &mut F) where
    F: FnMut(&mut L::LastDim, &<[R; M] as CountElements>::Dtype), 

Applies f to the last dimension of l, where r is broadcasted to be the same size as l.

fn foreachlast_brb<F>(
    o: BroadcastMut<'_, [O; M]>,
    l: &[L; M],
    r: Broadcast<'_, [R; M]>,
    f: &mut F
) where
    F: FnMut(&mut O::Dtype, &L::LastDim, &R::Dtype), 

Applies f to the last dimension of l, where out and r are broadcasted to be the same size as l.

impl<const M: usize> ForEachLast<f32, [f32; M], usize> for Cpu

fn foreachlast_mb<F>(l: &mut [f32; M], r: Broadcast<'_, usize>, f: &mut F) where
    F: FnMut(&mut [f32; M], &usize), 

Applies f to the last dimension of l, where r is broadcasted to be the same size as l.

fn foreachlast_brb<F>(
    o: BroadcastMut<'_, f32>,
    l: &[f32; M],
    r: Broadcast<'_, usize>,
    f: &mut F
) where
    F: FnMut(&mut f32, &[f32; M], &usize), 

Applies f to the last dimension of l, where out and r are broadcasted to be the same size as l.

impl<T: CountElements, const M: usize> ReduceElements<[T; M]> for Cpu where
    Self: ReduceElements<T>, 

fn reduce<F: FnMut(T::Dtype, T::Dtype) -> T::Dtype>(
    inp: &[T; M],
    f: &mut F
) -> T::Dtype

impl ReduceElements<f32> for Cpu

fn reduce<F: FnMut(f32, f32) -> f32>(inp: &f32, _f: &mut F) -> f32

impl<T: MultiDimensional, const M: usize> ReduceLastDim<[T; M]> for Cpu where
    Self: ReduceLastDim<T, Reduced = T::Reduced>, 

const LAST_DIM: usize = T::LAST_DIM_SIZE

type Reduced = [<T as MultiDimensional>::Reduced; M]

fn reduce_last_dim_into<F>(inp: &[T; M], out: &mut Self::Reduced, f: &mut F) where
    F: FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

fn reduce_last_dim<F>(inp: &T, f: &mut F) -> Box<Self::Reduced> where
    F: FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize> ReduceLastDim<[f32; M]> for Cpu

const LAST_DIM: usize = M

type Reduced = f32

fn reduce_last_dim_into<F>(inp: &[f32; M], out: &mut Self::Reduced, f: &mut F) where
    F: FnMut(f32, f32) -> f32, 

fn reduce_last_dim<F>(inp: &T, f: &mut F) -> Box<Self::Reduced> where
    F: FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl ReduceLastDim<f32> for Cpu

const LAST_DIM: usize = 1usize

type Reduced = f32

fn reduce_last_dim_into<F>(inp: &f32, out: &mut Self::Reduced, _f: &mut F) where
    F: FnMut(f32, f32) -> f32, 

fn reduce_last_dim<F>(inp: &T, f: &mut F) -> Box<Self::Reduced> where
    F: FnMut(T::Dtype, T::Dtype) -> T::Dtype,