Trait tc_tensor::TensorTransform

pub trait TensorTransform {
    type Broadcast: TensorInstance;
    type Cast: TensorInstance;
    type Expand: TensorInstance;
    type Flip: TensorInstance;
    type Reshape: 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 flip(self, axis: usize) -> TCResult<Self::Flip>;
    fn reshape(self, shape: Shape) -> TCResult<Self::Reshape>;
    fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>;
    fn transpose(
        self,
        permutation: Option<Vec<usize>>
    ) -> TCResult<Self::Transpose>;
}

Tensor transforms

Required 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 Flip: TensorInstance

A Tensor flipped around one axis

type Reshape: TensorInstance

A reshaped Tensor

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 flip(self, axis: usize) -> TCResult<Self::Flip>

Flip this Tensor around the given axis.

fn reshape(self, shape: Shape) -> TCResult<Self::Reshape>

Change the shape of this Tensor.

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
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    D::Write: DirCreateFile<FD>,

type Broadcast = Tensor<FD, FS, D, T>

type Cast = Tensor<FD, FS, D, T>

type Expand = Tensor<FD, FS, D, T>

type Flip = Tensor<FD, FS, D, T>

type Reshape = Tensor<FD, FS, D, T>

type Slice = Tensor<FD, FS, D, T>

type Transpose = Tensor<FD, FS, D, T>

impl<FD, FS, D, T, A> TensorTransform for SparseTensor<FD, FS, D, T, A>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    A: SparseAccess<FD, FS, D, T>,
    D::Write: DirCreateFile<FD>,

type Broadcast = SparseTensor<FD, FS, D, T, SparseAccessor<FD, FS, D, T>>

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 Flip = SparseTensor<FD, FS, D, T, SparseFlip<FD, FS, D, T, A>>

type Reshape = SparseTensor<FD, FS, D, T, SparseReshape<FD, FS, D, T, A>>

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

type Transpose = SparseTensor<FD, FS, D, T, SparseAccessor<FD, FS, D, T>>

impl<FD, FS, D, T, B> TensorTransform for DenseTensor<FD, FS, D, T, B>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    B: DenseAccess<FD, FS, D, T>,
    D::Write: DirCreateFile<FD>,

type Broadcast = DenseTensor<FD, FS, D, T, DenseAccessor<FD, FS, D, T>>

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 Flip = DenseTensor<FD, FS, D, T, BlockListFlip<FD, FS, D, T, B>>

type Reshape = DenseTensor<FD, FS, D, T, BlockListReshape<FD, FS, D, T, B>>

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

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