Trait dfdx::tensor_ops::TryConcatAlong

pub trait TryConcatAlong<Ax>: Sized {
    type Output;
    type Error: Debug;

    // Required method
    fn try_concat_along(self, ax: Ax) -> Result<Self::Output, Self::Error>;

    // Provided method
    fn concat_along(self, ax: Ax) -> Self::Output { ... }
}

Concatenate two tensors along a given axis.

Pytorch equivalent torch.concat.

Const dims requires nightly

Along Axis 0:

let a: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let b: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank2<6, 4>, f32, _> = (a, b).concat_along(Axis::<0>);

Along Axis 1:

let a: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let b: Tensor<Rank2<3, 4>, f32, _> = dev.zeros();
let _: Tensor<Rank2<3, 8>, f32, _> = (a, b).concat_along(Axis::<1>);

usize dims

Along Axis 0:

let a: Tensor<(usize, Const<3>), f32, _> = dev.zeros_like(&(2, Const));
let b: Tensor<(usize, Const<3>), f32, _> = dev.zeros_like(&(4, Const));
let _: Tensor<Rank2<6, 3>, f32, _> = (a, b).concat_along(Axis::<0>).realize();

Along Axis 1:

let a: Tensor<(Const<2>, usize), f32, _> = dev.zeros_like(&(Const, 2));
let b: Tensor<(Const<2>, usize), f32, _> = dev.zeros_like(&(Const, 4));
let _: Tensor<Rank2<2, 6>, f32, _> = (a, b).concat_along(Axis::<1>).realize();

Required Associated Types

type Output

type Error: Debug

Required Methods

fn try_concat_along(self, ax: Ax) -> Result<Self::Output, Self::Error>

Fallibly concatenates self along the given axis.

Provided Methods

fn concat_along(self, ax: Ax) -> Self::Output

Concatenates self along the given axis.

Implementations on Foreign Types

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim, D4: Dim, D5: Dim> TryConcatAlong<Axis<3>> for ((D0, D1, D2, A, D4, D5), (D0, D1, D2, B, D4, D5))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, <A as Add<B>>::Output, D4, D5)

type Error = Infallible

fn try_concat_along(self, _: Axis<3>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim, D4: Dim> TryConcatAlong<Axis<3>> for ((D0, D1, D2, A, D4), (D0, D1, D2, B, D4))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, <A as Add<B>>::Output, D4)

type Error = Infallible

fn try_concat_along(self, _: Axis<3>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D1: Dim, D2: Dim, D3: Dim, D4: Dim> TryConcatAlong<Axis<0>> for ((A, D1, D2, D3, D4), (B, D1, D2, D3, D4))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output, D1, D2, D3, D4)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D1: Dim> TryConcatAlong<Axis<0>> for ((A, D1), (B, D1))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output, D1)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim, D3: Dim, D5: Dim> TryConcatAlong<Axis<4>> for ((D0, D1, D2, D3, A, D5), (D0, D1, D2, D3, B, D5))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, D3, <A as Add<B>>::Output, D5)

type Error = Infallible

fn try_concat_along(self, _: Axis<4>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D3: Dim, D4: Dim, D5: Dim> TryConcatAlong<Axis<2>> for ((D0, D1, A, D3, D4, D5), (D0, D1, B, D3, D4, D5))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, <A as Add<B>>::Output, D3, D4, D5)

type Error = Infallible

fn try_concat_along(self, _: Axis<2>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim> TryConcatAlong<Axis<2>> for ((D0, D1, A), (D0, D1, B))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, <A as Add<B>>::Output)

type Error = Infallible

fn try_concat_along(self, _: Axis<2>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D3: Dim, D4: Dim> TryConcatAlong<Axis<2>> for ((D0, D1, A, D3, D4), (D0, D1, B, D3, D4))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, <A as Add<B>>::Output, D3, D4)

type Error = Infallible

fn try_concat_along(self, _: Axis<2>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim> TryConcatAlong<Axis<1>> for ((D0, A), (D0, B))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, <A as Add<B>>::Output)

type Error = Infallible

fn try_concat_along(self, _: Axis<1>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim> TryConcatAlong<Axis<0>> for ((A,), (B,))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output,)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D3: Dim> TryConcatAlong<Axis<2>> for ((D0, D1, A, D3), (D0, D1, B, D3))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, <A as Add<B>>::Output, D3)

type Error = Infallible

fn try_concat_along(self, _: Axis<2>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D1: Dim, D2: Dim> TryConcatAlong<Axis<0>> for ((A, D1, D2), (B, D1, D2))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output, D1, D2)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim, D3: Dim, D4: Dim> TryConcatAlong<Axis<5>> for ((D0, D1, D2, D3, D4, A), (D0, D1, D2, D3, D4, B))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, D3, D4, <A as Add<B>>::Output)

type Error = Infallible

fn try_concat_along(self, _: Axis<5>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D2: Dim> TryConcatAlong<Axis<1>> for ((D0, A, D2), (D0, B, D2))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, <A as Add<B>>::Output, D2)

type Error = Infallible

fn try_concat_along(self, _: Axis<1>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim> TryConcatAlong<Axis<3>> for ((D0, D1, D2, A), (D0, D1, D2, B))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, <A as Add<B>>::Output)

type Error = Infallible

fn try_concat_along(self, _: Axis<3>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D2: Dim, D3: Dim, D4: Dim, D5: Dim> TryConcatAlong<Axis<1>> for ((D0, A, D2, D3, D4, D5), (D0, B, D2, D3, D4, D5))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, <A as Add<B>>::Output, D2, D3, D4, D5)

type Error = Infallible

fn try_concat_along(self, _: Axis<1>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D2: Dim, D3: Dim> TryConcatAlong<Axis<1>> for ((D0, A, D2, D3), (D0, B, D2, D3))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, <A as Add<B>>::Output, D2, D3)

type Error = Infallible

fn try_concat_along(self, _: Axis<1>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D1: Dim, D2: Dim, D3: Dim> TryConcatAlong<Axis<4>> for ((D0, D1, D2, D3, A), (D0, D1, D2, D3, B))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, D1, D2, D3, <A as Add<B>>::Output)

type Error = Infallible

fn try_concat_along(self, _: Axis<4>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D1: Dim, D2: Dim, D3: Dim> TryConcatAlong<Axis<0>> for ((A, D1, D2, D3), (B, D1, D2, D3))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output, D1, D2, D3)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D0: Dim, D2: Dim, D3: Dim, D4: Dim> TryConcatAlong<Axis<1>> for ((D0, A, D2, D3, D4), (D0, B, D2, D3, D4))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (D0, <A as Add<B>>::Output, D2, D3, D4)

type Error = Infallible

fn try_concat_along(self, _: Axis<1>) -> Result<Self::Output, Self::Error>

impl<A, B, Ax, E: Dtype, D, T, R: Tape<E, D>> TryConcatAlong<Ax> for (Tensor<A, E, D, T>, Tensor<B, E, D, R>)where Ax: Axes<Array = [isize; 1]>, D: ConcatAlongKernel<E> + ZerosTensor<E>, A: Shape + HasAxes<Ax>, B: Shape<Concrete = A::Concrete> + HasAxes<Ax>, (A, B): TryConcatAlong<Ax>, <(A, B) as TryConcatAlong<Ax>>::Output: Shape, T: Merge<R> + Tape<E, D>,

type Output = Tensor<<(A, B) as TryConcatAlong<Ax>>::Output, E, D, T>

type Error = <D as HasErr>::Err

fn try_concat_along(self, ax: Ax) -> Result<Self::Output, Self::Error>

impl<A, B: Dim, D1: Dim, D2: Dim, D3: Dim, D4: Dim, D5: Dim> TryConcatAlong<Axis<0>> for ((A, D1, D2, D3, D4, D5), (B, D1, D2, D3, D4, D5))where A: Add<B> + Dim, <A as Add<B>>::Output: Dim,

type Output = (<A as Add<B>>::Output, D1, D2, D3, D4, D5)

type Error = Infallible

fn try_concat_along(self, _: Axis<0>) -> Result<Self::Output, Self::Error>

Implementors