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 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 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_with<Sh, Ds, R>(shape: Sh, distr: Ds, rng: &mut R) -> Self

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

generates a randomly initialized set of parameters with the given shape using the output of the given distribution

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

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

generates a randomly initialized set of parameters with the given shape using the output of the given 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, 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, 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> Initialize<S, D> for TensorBase<S, D>

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

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

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

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

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

fn bernoulli<Sh>(shape: Sh, p: f64) -> Result<Self, BernoulliError>

where Bernoulli: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

fn glorot_normal<Sh>(shape: Sh) -> Self

where Sh: ShapeBuilder<Dim = D>, StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, <S as RawData>::Elem: Float + FromPrimitive,

Initialize the object according to the Glorot Initialization scheme.

fn glorot_uniform<Sh>(shape: Sh) -> Result<Self, InitError>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Float + FromPrimitive + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone,

Initialize the object according to the Glorot Initialization scheme.

fn lecun_normal<Sh>(shape: Sh) -> Self

where StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Float,

Initialize the object according to the Lecun Initialization scheme. LecunNormal distributions are truncated Normal distributions centered at 0 with a standard deviation equal to the square root of the reciprocal of the number of inputs.

fn normal<Sh>( shape: Sh, mean: <S as RawData>::Elem, std: <S as RawData>::Elem, ) -> Result<Self, Error>

where StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Float,

Given a shape, mean, and standard deviation generate a new object using the Normal distribution

fn randc<Sh>( shape: Sh, re: <S as RawData>::Elem, im: <S as RawData>::Elem, ) -> Self

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, ComplexDistribution<<S as RawData>::Elem>: Distribution<<S as RawData>::Elem>,

fn stdnorm<Sh>(shape: Sh) -> Self

where StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Generate a random array using the StandardNormal distribution

fn stdnorm_from_seed<Sh>(shape: Sh, seed: u64) -> Self

where StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>,

Generate a random array using the StandardNormal distribution with a given seed

fn truncnorm<Sh>( shape: Sh, mean: <S as RawData>::Elem, std: <S as RawData>::Elem, ) -> Result<Self, InitError>

where StandardNormal: Distribution<<S as RawData>::Elem>, S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Float,

Initialize the object using the TruncatedNormal distribution

fn uniform<Sh>(shape: Sh, dk: <S as RawData>::Elem) -> Result<Self, InitError>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Clone + Neg<Output = <S as RawData>::Elem> + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values bounded by +/- dk

fn uniform_from_seed<Sh>( shape: Sh, start: <S as RawData>::Elem, stop: <S as RawData>::Elem, key: u64, ) -> Result<Self, InitError>

where S: DataOwned, Sh: ShapeBuilder<Dim = D>, <S as RawData>::Elem: Clone + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone,

randomly initialize the object using the Uniform distribution with values between the start and stop params using some random seed.

fn uniform_along<Sh>(shape: Sh, axis: usize) -> Result<Self, InitError>

where Sh: ShapeBuilder<Dim = D>, S: DataOwned, <S as RawData>::Elem: Float + FromPrimitive + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values bounded by the size of the specified axis. The values are bounded by +/- dk where dk = 1 / size(axis).

fn uniform_between<Sh>( shape: Sh, a: <S as RawData>::Elem, b: <S as RawData>::Elem, ) -> Result<Self, InitError>

where Sh: ShapeBuilder<Dim = D>, S: DataOwned, <S as RawData>::Elem: Clone + SampleUniform, <<S as RawData>::Elem as SampleUniform>::Sampler: Clone,

initialize the object using the Uniform distribution with values between then given bounds, a and b.

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,