Struct dfdx::devices::Cpu

pub struct Cpu;

The CPU device

Implementations

impl Cpu

pub fn vm<const K: usize, const N: usize>(
    a: &[f32; K],
    b: &[[f32; N]; K],
    c: &mut [f32; N]
)

vector matrix multiply c += a * b

pub fn vm_bt<const K: usize, const N: usize>(
    a: &[f32; K],
    b_t: &[[f32; K]; N],
    c: &mut [f32; N]
)

vector matrix multiply c += a * trans(b)

pub fn vv<const M: usize, const N: usize>(
    a: &[f32; M],
    b: &[f32; N],
    c: &mut [[f32; N]; M]
)

vector vector

Trait Implementations

impl AllocateZeros for Cpu

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

Allocates using alloc_zeroed.

impl<const M: usize, const N: usize, const O: usize, const P: usize> Device<[[[[f32; P]; O]; N]; M]> 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 sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

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<const M: usize, const N: usize, const O: usize> Device<[[[f32; O]; N]; M]> 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 sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

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<const M: usize, const N: usize> Device<[[f32; N]; M]> 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 sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

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<const M: usize> Device<[f32; M]> 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 sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

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 sub(lhs: &mut T, rhs: &T) where
    T::Dtype: for<'r> SubAssign<&'r T::Dtype> + Copy, 

Computes lhs -= rhs using ForEachElement::foreach_mr

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<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast1<[[[f32; O]; N]; M], [[[[f32; P]; O]; N]; M], -1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast1<[[[f32; O]; N]; M], [[[[f32; P]; O]; N]; M], 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast1<[[[f32; P]; N]; M], [[[[f32; P]; O]; N]; M], 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; P]; N]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[[f32; P]; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast1<[[[f32; P]; O]; M], [[[[f32; P]; O]; N]; M], 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; P]; O]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[[f32; P]; O]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast1<[[[f32; P]; O]; N], [[[[f32; P]; O]; N]; M], 0> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; P]; O]; N],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[[f32; P]; O]; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast1<[[f32; N]; M], [[[f32; O]; N]; M], -1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[f32; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast1<[[f32; N]; M], [[[f32; O]; N]; M], 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[f32; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast1<[[f32; O]; M], [[[f32; O]; N]; M], 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; O]; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[f32; O]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast1<[[f32; O]; N], [[[f32; O]; N]; M], 0> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; O]; N],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[[f32; O]; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize> ForEachBroadcast1<[f32; M], [[f32; N]; M], -1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; M],
    b: &[[f32; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[f32; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize> ForEachBroadcast1<[f32; M], [[f32; N]; M], 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; M],
    b: &[[f32; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[f32; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize> ForEachBroadcast1<[f32; N], [[f32; N]; M], 0> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; N],
    b: &[[f32; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[f32; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize> ForEachBroadcast1<f32, [f32; M], -1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(a: &mut f32, b: &[f32; M], f: &mut F)

fn foreach_br<F: FnMut(&mut f32, &f32)>(a: &mut [f32; M], b: &f32, f: &mut F)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

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

fn foreach_mb<F: FnMut(&mut f32, &f32)>(a: &mut f32, b: &[f32; M], f: &mut F)

fn foreach_br<F: FnMut(&mut f32, &f32)>(a: &mut [f32; M], b: &f32, f: &mut F)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl ForEachBroadcast1<f32, f32, -1> for Cpu

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

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

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl ForEachBroadcast1<f32, f32, 0> for Cpu

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

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

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; N]; M], [[[[f32; P]; O]; N]; M], 2, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; N]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; N]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; O]; M], [[[[f32; P]; O]; N]; M], 1, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; O]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; O]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; O]; N], [[[[f32; P]; O]; N]; M], 0, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; O]; N],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; O]; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; P]; M], [[[[f32; P]; O]; N]; M], 1, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; P]; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; P]; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; P]; N], [[[[f32; P]; O]; N]; M], 0, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; P]; N],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; P]; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast2<[[f32; P]; O], [[[[f32; P]; O]; N]; M], 0, 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [[f32; P]; O],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[[f32; P]; O],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast2<[f32; M], [[[f32; O]; N]; M], 1, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; M],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[f32; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast2<[f32; N], [[[f32; O]; N]; M], 0, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; N],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[f32; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast2<[f32; O], [[[f32; O]; N]; M], 0, 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; O],
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &[f32; O],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize> ForEachBroadcast2<f32, [[f32; N]; M], 0, 1> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(a: &mut f32, b: &[[f32; N]; M], f: &mut F)

fn foreach_br<F: FnMut(&mut f32, &f32)>(a: &mut [[f32; N]; M], b: &f32, f: &mut F)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast3<[f32; M], [[[[f32; P]; O]; N]; M], 1, 2, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; M],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[f32; M],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast3<[f32; N], [[[[f32; P]; O]; N]; M], 0, 2, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; N],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[f32; N],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast3<[f32; O], [[[[f32; P]; O]; N]; M], 0, 1, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; O],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[f32; O],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast3<[f32; P], [[[[f32; P]; O]; N]; M], 0, 1, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut [f32; P],
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &[f32; P],
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize> ForEachBroadcast3<f32, [[[f32; O]; N]; M], 0, 1, 2> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut f32,
    b: &[[[f32; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[f32; O]; N]; M],
    b: &f32,
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

impl<const M: usize, const N: usize, const O: usize, const P: usize> ForEachBroadcast4<f32, [[[[f32; P]; O]; N]; M], 0, 1, 2, 3> for Cpu

fn foreach_mb<F: FnMut(&mut f32, &f32)>(
    a: &mut f32,
    b: &[[[[f32; P]; O]; N]; M],
    f: &mut F
)

fn foreach_br<F: FnMut(&mut f32, &f32)>(
    a: &mut [[[[f32; P]; O]; N]; M],
    b: &f32,
    f: &mut F
)

fn broadcast_copy(a: &mut Lg, b: &Sm)

fn broadcast_add(a: &mut Sm, b: &Lg)

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<const BATCH: usize, const M: usize, const K: usize, const N: usize> MatMul<[[[f32; K]; M]; BATCH], [[[f32; N]; K]; BATCH], [[f32; N]; M]> for Cpu where
    Self: MatMul<[[f32; K]; M], [[f32; N]; K], [[f32; N]; M]>, 

fn mm(
    a: &[[[f32; K]; M]; BATCH],
    b: &[[[f32; N]; K]; BATCH],
    c: &mut [[f32; N]; M]
)

Broadcast c BATCH times.

fn mm_at(
    a: &[[[f32; M]; K]; BATCH],
    b: &[[[f32; N]; K]; BATCH],
    c: &mut [[f32; N]; M]
)

Broadcast c BATCH times.

fn mm_bt(
    a: &[[[f32; K]; M]; BATCH],
    b: &[[[f32; K]; N]; BATCH],
    c: &mut [[f32; N]; M]
)

Broadcast c BATCH times.

fn mm_atct(
    a: &[[[f32; M]; K]; BATCH],
    b: &[[[f32; N]; K]; BATCH],
    c: &mut [[f32; M]; N]
)

Broadcast c BATCH times.

impl<const BATCH: usize, const M: usize, const K: usize, const N: usize> MatMul<[[[f32; K]; M]; BATCH], [[f32; N]; K], [[[f32; N]; M]; BATCH]> for Cpu where
    Self: MatMul<[[f32; K]; M], [[f32; N]; K], [[f32; N]; M]>, 

fn mm(
    a: &[[[f32; K]; M]; BATCH],
    b: &[[f32; N]; K],
    c: &mut [[[f32; N]; M]; BATCH]
)

Broadcast b BATCH times.

fn mm_at(
    a: &[[[f32; M]; K]; BATCH],
    b: &[[f32; N]; K],
    c: &mut [[[f32; N]; M]; BATCH]
)

Broadcast b BATCH times.

fn mm_bt(
    a: &[[[f32; K]; M]; BATCH],
    b: &[[f32; K]; N],
    c: &mut [[[f32; N]; M]; BATCH]
)

Broadcast b BATCH times.

fn mm_atct(
    a: &[[[f32; M]; K]; BATCH],
    b: &[[f32; N]; K],
    c: &mut [[[f32; M]; N]; BATCH]
)

Broadcast b BATCH times.

impl<const M: usize, const K: usize, const N: usize> MatMul<[[f32; K]; M], [[f32; N]; K], [[f32; N]; M]> for Cpu

fn mm(a: &[[f32; K]; M], b: &[[f32; N]; K], c: &mut [[f32; N]; M])

Matmul

fn mm_at(a: &[[f32; M]; K], b: &[[f32; N]; K], c: &mut [[f32; N]; M])

Matmul, a is transposed.

fn mm_bt(a: &[[f32; K]; M], b: &[[f32; K]; N], c: &mut [[f32; N]; M])

Matmul, b is transposed

fn mm_atct(a: &[[f32; M]; K], b: &[[f32; N]; K], c: &mut [[f32; M]; N])

Matmul, a and c are transposed

impl<const BATCH: usize, A, B, C> MatMul<[A; BATCH], [B; BATCH], [C; BATCH]> for Cpu where
    Self: MatMul<A, B, C>,
    A: Transpose,
    B: Transpose,
    C: Transpose,
    [A; BATCH]: Transpose<T = [A::T; BATCH]>,
    [B; BATCH]: Transpose<T = [B::T; BATCH]>,
    [C; BATCH]: Transpose<T = [C::T; BATCH]>, 

fn mm(a: &[A; BATCH], b: &[B; BATCH], c: &mut [C; BATCH])

Batched matmul

fn mm_at(a: &[A::T; BATCH], b: &[B; BATCH], c: &mut [C; BATCH])

Batched matmul

fn mm_bt(a: &[A; BATCH], b: &[B::T; BATCH], c: &mut [C; BATCH])

Batched matmul

fn mm_atct(a: &[A::T; BATCH], b: &[B; BATCH], c: &mut [C::T; BATCH])

Batched matmul

impl<const M: usize, const N: usize, const O: usize, const P: usize> Reduce1Axis<[[[[f32; P]; O]; N]; M], [[[f32; O]; N]; M], -1> for Cpu

fn reduce_into<F>(
    inp: &[[[[f32; P]; O]; N]; M],
    out: &mut [[[f32; O]; N]; M],
    f: F
) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize, const P: usize> Reduce1Axis<[[[[f32; P]; O]; N]; M], [[[f32; O]; N]; M], 3> for Cpu

fn reduce_into<F>(
    inp: &[[[[f32; P]; O]; N]; M],
    out: &mut [[[f32; O]; N]; M],
    f: F
) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize, const P: usize> Reduce1Axis<[[[[f32; P]; O]; N]; M], [[[f32; P]; N]; M], 2> for Cpu

fn reduce_into<F>(
    inp: &[[[[f32; P]; O]; N]; M],
    out: &mut [[[f32; P]; N]; M],
    f: F
) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize, const P: usize> Reduce1Axis<[[[[f32; P]; O]; N]; M], [[[f32; P]; O]; M], 1> for Cpu

fn reduce_into<F>(
    inp: &[[[[f32; P]; O]; N]; M],
    out: &mut [[[f32; P]; O]; M],
    f: F
) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize, const P: usize> Reduce1Axis<[[[[f32; P]; O]; N]; M], [[[f32; P]; O]; N], 0> for Cpu

fn reduce_into<F>(
    inp: &[[[[f32; P]; O]; N]; M],
    out: &mut [[[f32; P]; O]; N],
    f: F
) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize> Reduce1Axis<[[[f32; O]; N]; M], [[f32; N]; M], -1> for Cpu

fn reduce_into<F>(inp: &[[[f32; O]; N]; M], out: &mut [[f32; N]; M], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize> Reduce1Axis<[[[f32; O]; N]; M], [[f32; N]; M], 2> for Cpu

fn reduce_into<F>(inp: &[[[f32; O]; N]; M], out: &mut [[f32; N]; M], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize> Reduce1Axis<[[[f32; O]; N]; M], [[f32; O]; M], 1> for Cpu

fn reduce_into<F>(inp: &[[[f32; O]; N]; M], out: &mut [[f32; O]; M], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize, const O: usize> Reduce1Axis<[[[f32; O]; N]; M], [[f32; O]; N], 0> for Cpu

fn reduce_into<F>(inp: &[[[f32; O]; N]; M], out: &mut [[f32; O]; N], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize> Reduce1Axis<[[f32; N]; M], [f32; M], -1> for Cpu

fn reduce_into<F>(inp: &[[f32; N]; M], out: &mut [f32; M], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize> Reduce1Axis<[[f32; N]; M], [f32; M], 1> for Cpu

fn reduce_into<F>(inp: &[[f32; N]; M], out: &mut [f32; M], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize, const N: usize> Reduce1Axis<[[f32; N]; M], [f32; N], 0> for Cpu

fn reduce_into<F>(inp: &[[f32; N]; M], out: &mut [f32; N], f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl<const M: usize> Reduce1Axis<[f32; M], f32, -1> for Cpu

fn reduce_into<F: Copy + FnMut(f32, f32) -> f32>(
    inp: &[f32; M],
    out: &mut f32,
    f: F
)

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

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

fn reduce_into<F: Copy + FnMut(f32, f32) -> f32>(
    inp: &[f32; M],
    out: &mut f32,
    f: F
)

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl Reduce1Axis<f32, f32, -1> for Cpu

fn reduce_into<F>(inp: &f32, out: &mut f32, _f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

impl Reduce1Axis<f32, f32, 0> for Cpu

fn reduce_into<F>(inp: &f32, out: &mut f32, _f: F) where
    F: Copy + FnMut(f32, f32) -> f32, 

fn reduce<F>(inp: &T, f: F) -> Box<R> where
    F: Copy + FnMut(T::Dtype, T::Dtype) -> T::Dtype, 

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

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

impl ReduceAllElements<f32> for Cpu

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

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [[[[usize; Z]; O]; N]; M], [[[[f32; Z]; O]; N]; M], -1> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[[[[usize; Z]; O]; N]; M],
    out: &mut [[[[f32; Z]; O]; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[[[[usize; Z]; O]; N]; M],
    out: &[[[[f32; Z]; O]; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [[[usize; O]; N]; M], [[[f32; O]; N]; M], -1> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[[[usize; O]; N]; M],
    out: &mut [[[f32; O]; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[[[usize; O]; N]; M],
    out: &[[[f32; O]; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [[[usize; Z]; N]; M], [[[[f32; P]; Z]; N]; M], 2> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[[[usize; Z]; N]; M],
    out: &mut [[[[f32; P]; Z]; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[[[usize; Z]; N]; M],
    out: &[[[[f32; P]; Z]; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [[usize; N]; M], [[[f32; P]; N]; M], 2> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[[usize; N]; M],
    out: &mut [[[f32; P]; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[[usize; N]; M],
    out: &[[[f32; P]; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [[usize; Z]; M], [[[[f32; P]; O]; Z]; M], 1> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[[usize; Z]; M],
    out: &mut [[[[f32; P]; O]; Z]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[[usize; Z]; M],
    out: &[[[[f32; P]; O]; Z]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [usize; M], [[[f32; P]; O]; M], 1> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[usize; M],
    out: &mut [[[f32; P]; O]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[usize; M],
    out: &[[[f32; P]; O]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], [usize; Z], [[[[f32; P]; O]; N]; Z], 0> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &[usize; Z],
    out: &mut [[[[f32; P]; O]; N]; Z]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &[usize; Z],
    out: &[[[[f32; P]; O]; N]; Z]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const P: usize> SelectAlongAxis<[[[[f32; P]; O]; N]; M], usize, [[[f32; P]; O]; N], 0> for Cpu

fn select_axis(
    inp: &[[[[f32; P]; O]; N]; M],
    indices: &usize,
    out: &mut [[[f32; P]; O]; N]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[[f32; P]; O]; N]; M],
    indices: &usize,
    out: &[[[f32; P]; O]; N]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const Z: usize> SelectAlongAxis<[[[f32; O]; N]; M], [[[usize; Z]; N]; M], [[[f32; Z]; N]; M], -1> for Cpu

fn select_axis(
    inp: &[[[f32; O]; N]; M],
    indices: &[[[usize; Z]; N]; M],
    out: &mut [[[f32; Z]; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[f32; O]; N]; M],
    indices: &[[[usize; Z]; N]; M],
    out: &[[[f32; Z]; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize> SelectAlongAxis<[[[f32; O]; N]; M], [[usize; N]; M], [[f32; N]; M], -1> for Cpu

fn select_axis(
    inp: &[[[f32; O]; N]; M],
    indices: &[[usize; N]; M],
    out: &mut [[f32; N]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[f32; O]; N]; M],
    indices: &[[usize; N]; M],
    out: &[[f32; N]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const Z: usize> SelectAlongAxis<[[[f32; O]; N]; M], [[usize; Z]; M], [[[f32; O]; Z]; M], 1> for Cpu

fn select_axis(
    inp: &[[[f32; O]; N]; M],
    indices: &[[usize; Z]; M],
    out: &mut [[[f32; O]; Z]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[f32; O]; N]; M],
    indices: &[[usize; Z]; M],
    out: &[[[f32; O]; Z]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize> SelectAlongAxis<[[[f32; O]; N]; M], [usize; M], [[f32; O]; M], 1> for Cpu

fn select_axis(
    inp: &[[[f32; O]; N]; M],
    indices: &[usize; M],
    out: &mut [[f32; O]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[f32; O]; N]; M],
    indices: &[usize; M],
    out: &[[f32; O]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize, const Z: usize> SelectAlongAxis<[[[f32; O]; N]; M], [usize; Z], [[[f32; O]; N]; Z], 0> for Cpu

fn select_axis(
    inp: &[[[f32; O]; N]; M],
    indices: &[usize; Z],
    out: &mut [[[f32; O]; N]; Z]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[[f32; O]; N]; M],
    indices: &[usize; Z],
    out: &[[[f32; O]; N]; Z]
)

inp[indices] += out

impl<const M: usize, const N: usize, const O: usize> SelectAlongAxis<[[[f32; O]; N]; M], usize, [[f32; O]; N], 0> for Cpu

fn select_axis(inp: &[[[f32; O]; N]; M], indices: &usize, out: &mut [[f32; O]; N])

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [[[f32; O]; N]; M], indices: &usize, out: &[[f32; O]; N])

inp[indices] += out

impl<const M: usize, const N: usize, const Z: usize> SelectAlongAxis<[[f32; N]; M], [[usize; Z]; M], [[f32; Z]; M], -1> for Cpu

fn select_axis(
    inp: &[[f32; N]; M],
    indices: &[[usize; Z]; M],
    out: &mut [[f32; Z]; M]
)

Equivalent to psuedocode out = inp[indices]

fn select_add(
    inp: &mut [[f32; N]; M],
    indices: &[[usize; Z]; M],
    out: &[[f32; Z]; M]
)

inp[indices] += out

impl<const M: usize, const N: usize> SelectAlongAxis<[[f32; N]; M], [usize; M], [f32; M], -1> for Cpu

fn select_axis(inp: &[[f32; N]; M], indices: &[usize; M], out: &mut [f32; M])

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [[f32; N]; M], indices: &[usize; M], out: &[f32; M])

inp[indices] += out

impl<const M: usize, const N: usize, const Z: usize> SelectAlongAxis<[[f32; N]; M], [usize; Z], [[f32; N]; Z], 0> for Cpu

fn select_axis(inp: &[[f32; N]; M], indices: &[usize; Z], out: &mut [[f32; N]; Z])

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [[f32; N]; M], indices: &[usize; Z], out: &[[f32; N]; Z])

inp[indices] += out

impl<const M: usize, const N: usize> SelectAlongAxis<[[f32; N]; M], usize, [f32; N], 0> for Cpu

fn select_axis(inp: &[[f32; N]; M], indices: &usize, out: &mut [f32; N])

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [[f32; N]; M], indices: &usize, out: &[f32; N])

inp[indices] += out

impl<const M: usize, const Z: usize> SelectAlongAxis<[f32; M], [usize; Z], [f32; Z], -1> for Cpu

fn select_axis(inp: &[f32; M], indices: &[usize; Z], out: &mut [f32; Z])

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [f32; M], indices: &[usize; Z], out: &[f32; Z])

inp[indices] += out

impl<const M: usize> SelectAlongAxis<[f32; M], usize, f32, -1> for Cpu

fn select_axis(inp: &[f32; M], indices: &usize, out: &mut f32)

Equivalent to psuedocode out = inp[indices]

fn select_add(inp: &mut [f32; M], indices: &usize, out: &f32)

inp[indices] += out

impl<A: Transpose, B: Transpose, C: Transpose> MatMulOp<A, B, C> for Cpu where
    Self: MatMul<A, B, C> + MatMul<C, B::T, A> + MatMul<A::T, C, B>,