Trait tc_tensor::TensorTransform

pub trait TensorTransform {
    type Broadcast: TensorInstance;
    type Cast: TensorInstance;
    type Expand: TensorInstance;
    type Slice: TensorInstance;
    type Transpose: TensorInstance;
    fn broadcast(self, shape: Shape) -> TCResult<Self::Broadcast>;
    fn cast_into(self, dtype: NumberType) -> TCResult<Self::Cast>;
    fn expand_dims(self, axis: usize) -> TCResult<Self::Expand>;
    fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>;
    fn transpose(
        self, 
        permutation: Option<Vec<usize>>
    ) -> TCResult<Self::Transpose>;
}

Tensor transforms

Associated Types

type Broadcast: TensorInstance

A broadcast Tensor

type Cast: TensorInstance

A type-cast Tensor

type Expand: TensorInstance

A Tensor with an expanded dimension

type Slice: TensorInstance

A Tensor slice

type Transpose: TensorInstance

A transposed Tensor

Required methods

fn broadcast(self, shape: Shape) -> TCResult<Self::Broadcast>

Broadcast this Tensor to the given shape.

fn cast_into(self, dtype: NumberType) -> TCResult<Self::Cast>

Cast this Tensor to the given dtype.

fn expand_dims(self, axis: usize) -> TCResult<Self::Expand>

Insert a new dimension of size 1 at the given axis.

fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>

Return a slice of this Tensor with the given bounds.

fn transpose(self, permutation: Option<Vec<usize>>) -> TCResult<Self::Transpose>

Transpose this Tensor by reordering its axes according to the given permutation. If no permutation is given, the axes will be reversed.

Implementors

impl<FD, FS, D, T> TensorTransform for Tensor<FD, FS, D, T> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    D::FileClass: From<TensorType>, 

type Broadcast = Self

type Cast = Self

type Expand = Self

type Slice = Self

type Transpose = Self

impl<FD, FS, D, T, A> TensorTransform for SparseTensor<FD, FS, D, T, A> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    D::FileClass: From<TensorType>,
    A: SparseAccess<FD, FS, D, T>, 

type Broadcast = SparseTensor<FD, FS, D, T, SparseBroadcast<FD, FS, D, T, A>>

type Cast = SparseTensor<FD, FS, D, T, SparseCast<FD, FS, D, T, A>>

type Expand = SparseTensor<FD, FS, D, T, SparseExpand<FD, FS, D, T, A>>

type Slice = SparseTensor<FD, FS, D, T, A::Slice>

type Transpose = SparseTensor<FD, FS, D, T, A::Transpose>

impl<FD, FS, D, T, B> TensorTransform for DenseTensor<FD, FS, D, T, B> where
    D: Dir,
    T: Transaction<D>,
    FD: File<Array>,
    FS: File<Node>,
    D::File: AsType<FD> + AsType<FS>,
    B: DenseAccess<FD, FS, D, T>,
    D::FileClass: From<TensorType>, 

type Broadcast = DenseTensor<FD, FS, D, T, BlockListBroadcast<FD, FS, D, T, B>>

type Cast = DenseTensor<FD, FS, D, T, BlockListCast<FD, FS, D, T, B>>

type Expand = DenseTensor<FD, FS, D, T, BlockListExpand<FD, FS, D, T, B>>

type Slice = DenseTensor<FD, FS, D, T, B::Slice>

type Transpose = DenseTensor<FD, FS, D, T, B::Transpose>