Trait TensorVec

pub trait TensorVec
where
    Self: FromIterator<Self::Item> + Index<usize, Output = Self::Item> + IndexMut<usize>,
{
    type Item;
    type Slice<'a>;

    // Required methods
    fn append(&mut self, other: &mut Self);
    fn is_empty(&self) -> bool;
    fn len(&self) -> usize;
    fn new(slice: Self::Slice<'_>) -> Self;
    fn push(&mut self, item: Self::Item);
    fn remove(&mut self, _index: usize) -> Self::Item;
    fn retain<F>(&mut self, f: F)
       where F: FnMut(&Self::Item) -> bool;
    fn swap_remove(&mut self, _index: usize) -> Self::Item;
    fn zero(len: usize) -> Self;
}

Common methods for tensors derived from Vec.

Required Associated Types

type Item

The type of item encountered when iterating over the tensor.

type Slice<'a>

The type of slice corresponding to the tensor.

Required Methods

fn append(&mut self, other: &mut Self)

Moves all the items of other into self, leaving other empty.

fn is_empty(&self) -> bool

Returns true if the vector contains no items.

fn len(&self) -> usize

Returns the number of items in the vector, also referred to as its ‘length’.

fn new(slice: Self::Slice<'_>) -> Self

Returns a tensor given a slice.

fn push(&mut self, item: Self::Item)

Appends an item to the back of the Vec.

fn remove(&mut self, _index: usize) -> Self::Item

Removes an item from the Vec and returns it, shifting items to the left.

fn retain<F>(&mut self, f: F)

where F: FnMut(&Self::Item) -> bool,

Retains only the items specified by the predicate.

fn swap_remove(&mut self, _index: usize) -> Self::Item

Removes an item from the Vec and returns it, replacing it the last item.

fn zero(len: usize) -> Self

Returns the zero tensor.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl TensorVec for SquareMatrix

type Item = Vector

type Slice<'a> = &'a [&'a [f64]]

impl TensorVec for Vector

type Item = f64

type Slice<'a> = &'a [f64]

impl<const D: usize, const I: usize> TensorVec for TensorRank1Vec2D<D, I>

type Item = TensorRank1Vec<D, I>

type Slice<'a> = &'a [&'a [[f64; D]]]

impl<const D: usize, const I: usize> TensorVec for TensorRank1Vec<D, I>

type Item = TensorRank1<D, I>

type Slice<'a> = &'a [[f64; D]]

impl<const D: usize, const I: usize, const J: usize> TensorVec for TensorRank2Vec2D<D, I, J>

type Item = TensorRank2Vec<D, I, J>

type Slice<'a> = &'a [&'a [[[f64; D]; D]]]

impl<const D: usize, const I: usize, const J: usize> TensorVec for TensorRank2Vec<D, I, J>

type Item = TensorRank2<D, I, J>

type Slice<'a> = &'a [[[f64; D]; D]]