Struct TensorBase

pub struct TensorBase<S, D>
where
    D: Dimension,
    S: RawData,
{ /* private fields */ }

the TensorBase struct is the base type for all tensors in the library.

Implementations

impl<A, S, D> TensorBase<S, D>

where D: Dimension, S: RawData<Elem = A>,

pub const fn from_ndarray(store: ArrayBase<S, D>) -> Self

create a new TensorBase from the given store.

pub fn from_shape_fn<Sh, F>(shape: Sh, f: F) -> Self

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, F: FnMut(D::Pattern) -> A,

create a new TensorBase from the given shape and a function to fill it.

pub fn from_fn_with_shape<Sh, F>(shape: Sh, f: F) -> Self

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, F: Fn() -> A,

create a new TensorBase from the given shape and a function to fill it.

pub fn ones<Sh>(shape: Sh) -> Self

where A: Clone + One, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

returns a new instance of the TensorBase with the given shape and values initialized to zero.

pub fn zeros<Sh>(shape: Sh) -> Self

where A: Clone + Zero, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

returns a new instance of the TensorBase with the given shape and values initialized to zero.

pub fn dim(&self) -> D::Pattern

returns the dimension of the tensor as a Pattern

pub fn raw_dim(&self) -> D

returns the raw dimension, D, of the tensor

pub fn shape(&self) -> &[usize]

returns the shape of the tensor

pub fn get<Ix>(&self, index: Ix) -> Option<&A>

where S: Data, Ix: NdIndex<D>,

returns a reference to the element at the given index, if any

pub fn get_mut<Ix>(&mut self, index: Ix) -> Option<&mut A>

where S: DataMut, Ix: NdIndex<D>,

returns a mutable reference to the element at the given index, if any

pub fn map<F, B>(&self, f: F) -> Tensor<B, D>

where A: Clone, S: Data, F: FnMut(A) -> B,

applies the function to every element within the tensor

impl<A, S, D> TensorBase<S, D>

where D: Dimension, S: RawData<Elem = A>,

pub fn iter(&self) -> Iter<'_, A, D>

where S: Data,

returns an immutable iterator over the elements of the tensor

pub fn iter_mut(&mut self) -> IterMut<'_, A, D>

where S: DataMut,

returns a mutable iterator over the elements of the tensor

impl<A, S, D> TensorBase<S, D>

where D: Dimension, S: RawData<Elem = A>,

pub fn transpose(&self) -> TensorView<'_, A, D>

where S: Data,

transpose the current tensor, returning a new instance with a view of the transposed data.

impl<A, S, D> TensorBase<S, D>

where D: Dimension, S: RawData<Elem = A>,

pub fn to_owned(&self) -> Tensor<A, D>

where A: Clone, S: Data,

returns a new tensor with the same shape and values, but with an owned representation of the data.

pub fn to_shared(&self) -> ArcTensor<A, D>

where A: Clone, S: Data,

returns a new tensor with the same shape and values, but with an shared representation of the current data.

pub fn view(&self) -> TensorView<'_, A, D>

where S: Data,

returns a new tensor with the same shape and values, but with a view of the current data.

pub fn view_mut(&mut self) -> TensorViewMut<'_, A, D>

where S: DataMut,

returns a new tensor with the same shape and values, but with a mutable view of the current data.

impl<A, S, D> TensorBase<S, D>

where D: Dimension, S: DataOwned<Elem = A>,

pub fn random<Sh, Ds>(shape: Sh, distr: Ds) -> Self

where Ds: Distribution<A>, Sh: ShapeBuilder<Dim = D>,

generate a new tensor with the given shape and randomly initialized values

pub fn random_using<Sh, Ds, R>(shape: Sh, distr: Ds, rng: &mut R) -> Self

where R: RngCore + ?Sized, Ds: Distribution<A>, Sh: ShapeBuilder<Dim = D>,

randomly initializes a tensor with the given shape using the provided distribution and random number generator

pub fn random_with<Dst, Sh>(shape: Sh, distr: Dst) -> Self

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, Dst: Clone + Distribution<A>,

Randomly initializes a tensor with the given shape using the provided distribution

Trait Implementations

impl<A, S, D> Clone for TensorBase<S, D>

where A: Clone, S: RawDataClone<Elem = A>, D: Dimension,

fn clone(&self) -> Self

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, S, D> Debug for TensorBase<S, D>

where A: Debug, S: Data<Elem = A>, D: Dimension,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, A, S, D> Deserialize<'a> for TensorBase<S, D>

where A: Deserialize<'a>, D: Dimension + Deserialize<'a>, S: DataOwned<Elem = A>,

fn deserialize<De>(deserializer: De) -> Result<Self, De::Error>

where De: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<A, S, D> Display for TensorBase<S, D>

where A: Display, S: Data<Elem = A>, D: Dimension,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, S, D, X, S2, D2> Dot<X> for TensorBase<S, D>

where A: LinalgScalar, D: Dimension, D2: Dimension, S: RawData<Elem = A>, S2: RawData<Elem = A>, ArrayBase<S, D>: Dot<X, Output = ArrayBase<S2, D2>>,

type Output = TensorBase<S2, D2>

The result of the operation.

fn dot(&self, rhs: &X) -> Self::Output

impl<A, S, D> PartialEq<&ArrayBase<S, D>> for TensorBase<S, D>

where A: PartialEq, S: Data<Elem = A>, D: Dimension,

fn eq(&self, other: &&ArrayBase<S, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S, D> PartialEq<&mut ArrayBase<S, D>> for TensorBase<S, D>

where A: PartialEq, S: Data<Elem = A>, D: Dimension,

fn eq(&self, other: &&mut ArrayBase<S, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S, D> PartialEq<ArrayBase<S, D>> for TensorBase<S, D>

where A: PartialEq, S: Data<Elem = A>, D: Dimension,

fn eq(&self, other: &ArrayBase<S, D>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S, D> PartialEq for TensorBase<S, D>

where A: PartialEq, S: Data<Elem = A>, D: Dimension,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S, D> Serialize for TensorBase<S, D>

where A: Serialize, D: Dimension + Serialize, S: Data<Elem = A>,

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>

where Ser: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, A, S, D> Transpose for &'a TensorBase<S, D>

where A: 'a, S: Data<Elem = A>, D: Dimension,

type Output = TensorBase<ViewRepr<&'a A>, D>

the output, or result, of the transposition

fn transpose(&self) -> Self::Output

transpose a reference to the current object

impl<A, S, D> Copy for TensorBase<S, D>

where A: Copy, S: RawDataClone<Elem = A> + Copy, D: Dimension + Copy,