Struct dfdx::arrays::Axis

pub struct Axis<const I: isize>;

A single axis known at compile time

Trait Implementations

impl<const M: usize, const N: usize, H: Tape> BroadcastTo<Tensor2D<M, N, H>, Axis<0>> for Tensor1D<N, H>

fn broadcast(self) -> Tensor2D<M, N, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, H: Tape> BroadcastTo<Tensor2D<M, N, H>, Axis<1>> for Tensor1D<M, H>

fn broadcast(self) -> Tensor2D<M, N, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, H: Tape> BroadcastTo<Tensor3D<M, N, O, H>, Axis<0>> for Tensor2D<N, O, H>

fn broadcast(self) -> Tensor3D<M, N, O, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, H: Tape> BroadcastTo<Tensor3D<M, N, O, H>, Axis<1>> for Tensor2D<M, O, H>

fn broadcast(self) -> Tensor3D<M, N, O, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, H: Tape> BroadcastTo<Tensor3D<M, N, O, H>, Axis<2>> for Tensor2D<M, N, H>

fn broadcast(self) -> Tensor3D<M, N, O, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> BroadcastTo<Tensor4D<M, N, O, P, H>, Axis<0>> for Tensor3D<N, O, P, H>

fn broadcast(self) -> Tensor4D<M, N, O, P, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> BroadcastTo<Tensor4D<M, N, O, P, H>, Axis<1>> for Tensor3D<M, O, P, H>

fn broadcast(self) -> Tensor4D<M, N, O, P, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> BroadcastTo<Tensor4D<M, N, O, P, H>, Axis<2>> for Tensor3D<M, N, P, H>

fn broadcast(self) -> Tensor4D<M, N, O, P, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> BroadcastTo<Tensor4D<M, N, O, P, H>, Axis<3>> for Tensor3D<M, N, O, H>

fn broadcast(self) -> Tensor4D<M, N, O, P, H>

Broadcast self into T. This can be used to broadcast 1, 2, 3, and 4 axes.

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

type Reduced = [[[f32; P]; O]; N]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[[f32; P]; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[[f32; P]; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[[f32; P]; O]; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[[f32; P]; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[[f32; P]; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[[f32; P]; N]; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[[f32; P]; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[[f32; P]; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[[f32; O]; N]; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[[f32; P]; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[[f32; P]; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[f32; O]; N]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[f32; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[f32; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[f32; O]; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[f32; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[f32; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [[f32; N]; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[[f32; O]; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[[f32; O]; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [f32; N]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[f32; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[f32; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = [f32; M]

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(
    r: &mut Self::Reduced,
    t: &[[f32; N]; M]
)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [[f32; N]; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

type Reduced = f32

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(r: &mut Self::Reduced, t: &[f32; M])

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(
    t: &mut [f32; M],
    r: &Self::Reduced
)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

impl DeviceReduce<f32, Axis<0>> for Cpu

type Reduced = f32

The smaller type.

fn reduce_into_no_reset<A: Accumulator<f32>>(r: &mut Self::Reduced, t: &f32)

Reduces T into Self::Reduced with accumulator A without resetting the values in r.

fn broadcast_into_no_reset<A: Accumulator<f32>>(t: &mut f32, r: &Self::Reduced)

Broadcasts Self::Reduced into T with accumulator A without resetting the values in t.

fn reduce_into<A: Accumulator<T::Dtype>>(r: &mut Self::Reduced, t: &T)

Fills r with Accumulator::INIT before reducing.

fn broadcast_into<A: Accumulator<T::Dtype>>(t: &mut T, r: &Self::Reduced)

Fills t with Accumulator::INIT before broadcasting.

fn reduce<A: Accumulator<T::Dtype>>(t: &T) -> Box<Self::Reduced>

Allocates Self::Reduced then calls DeviceReduce::reduce_into()

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

const SIZE: usize = M

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = M

The size of the axis. E.g. an nd array of shape (M, N, O):

impl<const M: usize, const N: usize> HasAxes<Axis<0>> for [[f32; N]; M]

const SIZE: usize = M

The size of the axis. E.g. an nd array of shape (M, N, O):

impl<const M: usize> HasAxes<Axis<0>> for [f32; M]

const SIZE: usize = M

The size of the axis. E.g. an nd array of shape (M, N, O):

impl HasAxes<Axis<0>> for f32

const SIZE: usize = 1usize

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = N

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = N

The size of the axis. E.g. an nd array of shape (M, N, O):

impl<const M: usize, const N: usize> HasAxes<Axis<1>> for [[f32; N]; M]

const SIZE: usize = N

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = O

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = O

The size of the axis. E.g. an nd array of shape (M, N, O):

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

const SIZE: usize = P

The size of the axis. E.g. an nd array of shape (M, N, O):

impl<const M: usize, const N: usize, H: Tape> Reduce<Axis<0>> for Tensor2D<M, N, H>

type Reduced = Tensor1D<N, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor2D<M, N, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, H: Tape> Reduce<Axis<0>> for Tensor3D<M, N, O, H>

type Reduced = Tensor2D<N, O, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor3D<M, N, O, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> Reduce<Axis<0>> for Tensor4D<M, N, O, P, H>

type Reduced = Tensor3D<N, O, P, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor4D<M, N, O, P, H> as HasDevice>::Device

impl<const M: usize, const N: usize, H: Tape> Reduce<Axis<1>> for Tensor2D<M, N, H>

type Reduced = Tensor1D<M, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor2D<M, N, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, H: Tape> Reduce<Axis<1>> for Tensor3D<M, N, O, H>

type Reduced = Tensor2D<M, O, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor3D<M, N, O, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> Reduce<Axis<1>> for Tensor4D<M, N, O, P, H>

type Reduced = Tensor3D<M, O, P, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor4D<M, N, O, P, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, H: Tape> Reduce<Axis<2>> for Tensor3D<M, N, O, H>

type Reduced = Tensor2D<M, N, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor3D<M, N, O, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> Reduce<Axis<2>> for Tensor4D<M, N, O, P, H>

type Reduced = Tensor3D<M, N, P, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor4D<M, N, O, P, H> as HasDevice>::Device

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> Reduce<Axis<3>> for Tensor4D<M, N, O, P, H>

type Reduced = Tensor3D<M, N, O, H>

The resulting tensor type. This can be broadcast into Self via BroadcastTo.

type DeviceR = <Tensor4D<M, N, O, P, H> as HasDevice>::Device

impl<const M: usize, H: Tape> SelectTo<Tensor0D<H>, Axis<0>> for Tensor1D<M, H>

type Indices = usize

fn select(self, indices: &Self::Indices) -> Tensor0D<H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, H: Tape> SelectTo<Tensor1D<M, H>, Axis<1>> for Tensor2D<M, N, H>

type Indices = [usize; M]

fn select(self, indices: &Self::Indices) -> Tensor1D<M, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, H: Tape> SelectTo<Tensor1D<N, H>, Axis<0>> for Tensor2D<M, N, H>

type Indices = usize

fn select(self, indices: &Self::Indices) -> Tensor1D<N, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const Z: usize, H: Tape> SelectTo<Tensor1D<Z, H>, Axis<0>> for Tensor1D<M, H>

type Indices = [usize; Z]

fn select(self, indices: &Self::Indices) -> Tensor1D<Z, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const B: usize, const Z: usize, H: Tape> SelectTo<Tensor2D<B, Z, H>, Axis<0>> for Tensor1D<M, H>

type Indices = [[usize; Z]; B]

fn select(self, indices: &Self::Indices) -> Tensor2D<B, Z, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, H: Tape> SelectTo<Tensor2D<M, N, H>, Axis<2>> for Tensor3D<M, N, O, H>

type Indices = [[usize; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor2D<M, N, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, H: Tape> SelectTo<Tensor2D<M, O, H>, Axis<1>> for Tensor3D<M, N, O, H>

type Indices = [usize; M]

fn select(self, indices: &Self::Indices) -> Tensor2D<M, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const Z: usize, H: Tape> SelectTo<Tensor2D<M, Z, H>, Axis<1>> for Tensor2D<M, N, H>

type Indices = [[usize; Z]; M]

fn select(self, indices: &Self::Indices) -> Tensor2D<M, Z, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, H: Tape> SelectTo<Tensor2D<N, O, H>, Axis<0>> for Tensor3D<M, N, O, H>

type Indices = usize

fn select(self, indices: &Self::Indices) -> Tensor2D<N, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const Z: usize, H: Tape> SelectTo<Tensor2D<Z, N, H>, Axis<0>> for Tensor2D<M, N, H>

type Indices = [usize; Z]

fn select(self, indices: &Self::Indices) -> Tensor2D<Z, N, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const B: usize, const Z: usize, H: Tape> SelectTo<Tensor3D<B, Z, N, H>, Axis<0>> for Tensor2D<M, N, H>

type Indices = [[usize; Z]; B]

fn select(self, indices: &Self::Indices) -> Tensor3D<B, Z, N, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> SelectTo<Tensor3D<M, N, O, H>, Axis<3>> for Tensor4D<M, N, O, P, H>

type Indices = [[[usize; O]; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor3D<M, N, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> SelectTo<Tensor3D<M, N, P, H>, Axis<2>> for Tensor4D<M, N, O, P, H>

type Indices = [[usize; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor3D<M, N, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const Z: usize, H: Tape> SelectTo<Tensor3D<M, N, Z, H>, Axis<2>> for Tensor3D<M, N, O, H>

type Indices = [[[usize; Z]; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor3D<M, N, Z, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> SelectTo<Tensor3D<M, O, P, H>, Axis<1>> for Tensor4D<M, N, O, P, H>

type Indices = [usize; M]

fn select(self, indices: &Self::Indices) -> Tensor3D<M, O, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const Z: usize, H: Tape> SelectTo<Tensor3D<M, Z, O, H>, Axis<1>> for Tensor3D<M, N, O, H>

type Indices = [[usize; Z]; M]

fn select(self, indices: &Self::Indices) -> Tensor3D<M, Z, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> SelectTo<Tensor3D<N, O, P, H>, Axis<0>> for Tensor4D<M, N, O, P, H>

type Indices = usize

fn select(self, indices: &Self::Indices) -> Tensor3D<N, O, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const Z: usize, H: Tape> SelectTo<Tensor3D<Z, N, O, H>, Axis<0>> for Tensor3D<M, N, O, H>

type Indices = [usize; Z]

fn select(self, indices: &Self::Indices) -> Tensor3D<Z, N, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const B: usize, const Z: usize, H: Tape> SelectTo<Tensor4D<B, Z, N, O, H>, Axis<0>> for Tensor3D<M, N, O, H>

type Indices = [[usize; Z]; B]

fn select(self, indices: &Self::Indices) -> Tensor4D<B, Z, N, O, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize, H: Tape> SelectTo<Tensor4D<M, N, O, Z, H>, Axis<3>> for Tensor4D<M, N, O, P, H>

type Indices = [[[[usize; Z]; O]; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor4D<M, N, O, Z, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize, H: Tape> SelectTo<Tensor4D<M, N, Z, P, H>, Axis<2>> for Tensor4D<M, N, O, P, H>

type Indices = [[[usize; Z]; N]; M]

fn select(self, indices: &Self::Indices) -> Tensor4D<M, N, Z, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize, H: Tape> SelectTo<Tensor4D<M, Z, O, P, H>, Axis<1>> for Tensor4D<M, N, O, P, H>

type Indices = [[usize; Z]; M]

fn select(self, indices: &Self::Indices) -> Tensor4D<M, Z, O, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, const O: usize, const P: usize, const Z: usize, H: Tape> SelectTo<Tensor4D<Z, N, O, P, H>, Axis<0>> for Tensor4D<M, N, O, P, H>

type Indices = [usize; Z]

fn select(self, indices: &Self::Indices) -> Tensor4D<Z, N, O, P, H>

Select sub elements using Self::Indices. The same element can be selected multiple times depending on Self::Indices.

impl<const M: usize, const N: usize, H: Tape> ReduceTo<Tensor1D<M, H>, Axis<1>> for Tensor2D<M, N, H>

impl<const M: usize, const N: usize, H: Tape> ReduceTo<Tensor1D<N, H>, Axis<0>> for Tensor2D<M, N, H>

impl<const M: usize, const N: usize, const O: usize, H: Tape> ReduceTo<Tensor2D<M, N, H>, Axis<2>> for Tensor3D<M, N, O, H>

impl<const M: usize, const N: usize, const O: usize, H: Tape> ReduceTo<Tensor2D<M, O, H>, Axis<1>> for Tensor3D<M, N, O, H>

impl<const M: usize, const N: usize, const O: usize, H: Tape> ReduceTo<Tensor2D<N, O, H>, Axis<0>> for Tensor3D<M, N, O, H>

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> ReduceTo<Tensor3D<M, N, O, H>, Axis<3>> for Tensor4D<M, N, O, P, H>

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> ReduceTo<Tensor3D<M, N, P, H>, Axis<2>> for Tensor4D<M, N, O, P, H>

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> ReduceTo<Tensor3D<M, O, P, H>, Axis<1>> for Tensor4D<M, N, O, P, H>

impl<const M: usize, const N: usize, const O: usize, const P: usize, H: Tape> ReduceTo<Tensor3D<N, O, P, H>, Axis<0>> for Tensor4D<M, N, O, P, H>