Struct diffgeom::tensors::Tensor

pub struct Tensor<T: CoordinateSystem, U: Variance> where
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>,  { /* fields omitted */ }

Struct representing a tensor.

A tensor is anchored at a given point and has coordinates represented in the system defined by the generic parameter T. The variance of the tensor (meaning its rank and types of its indices) is defined by V. This allows Rust to decide at compile time whether two tensors are legal to be added / multiplied / etc.

It is only OK to perform an operation on two tensors if they belong to the same coordinate system.

Methods

impl<T, V> Tensor<T, V> where
    T: CoordinateSystem,
    V: Variance,
    T::Dimension: Pow<V::Rank>,
    Exp<T::Dimension, V::Rank>: ArrayLength<f64>, 

pub fn get_point(&self) -> &Point<T>

Returns the point at which the tensor is defined.

pub fn set_point(&mut self, p: Point<T>)

Sets the point at which the tensor is defined.

pub fn get_coord(i: &[usize]) -> usize

Converts a set of tensor indices passed as a slice into a single index for the internal array.

The length of the slice (the number of indices) has to be compatible with the rank of the tensor.

pub fn get_variance() -> Vec<IndexType>

Returns the variance of the tensor, that is, the list of the index types. A vector would return vec![Contravariant], a metric tensor: vec![Covariant, Covariant].

pub fn get_rank() -> usize

Returns the rank of the tensor

pub fn get_num_coords() -> usize

Returns the number of coordinates of the tensor (equal to [Dimension]^[Rank])

pub fn zero(point: Point<T>) -> Tensor<T, V>

Creates a new, zero tensor at a given point

pub fn new(
    point: Point<T>,
    coords: GenericArray<f64, Exp<T::Dimension, V::Rank>>
) -> Tensor<T, V>

Creates a tensor at a given point with the coordinates defined by the array.

The number of elements in the array must be equal to the number of coordinates of the tensor.

One-dimensional array represents an n-dimensional tensor in such a way, that the last index is the one that is changing the most often, i.e. the sequence is as follows: (0,0,...,0), (0,0,...,1), (0,0,...,2), ..., (0,0,...,1,0), (0,0,...,1,1), ... etc.

pub fn from_slice(point: Point<T>, slice: &[f64]) -> Tensor<T, V>

Creates a tensor at a given point with the coordinates defined by the slice.

The number of elements in the slice must be equal to the number of coordinates of the tensor.

One-dimensional slice represents an n-dimensional tensor in such a way, that the last index is the one that is changing the most often, i.e. the sequence is as follows: (0,0,...,0), (0,0,...,1), (0,0,...,2), ..., (0,0,...,1,0), (0,0,...,1,1), ... etc.

pub fn trace<Ul, Uh>(&self) -> Tensor<T, Contracted<V, Ul, Uh>> where
    Ul: Unsigned,
    Uh: Unsigned,
    V: Contract<Ul, Uh>,
    <Contracted<V, Ul, Uh> as Variance>::Rank: ArrayLength<usize>,
    T::Dimension: Pow<<Contracted<V, Ul, Uh> as Variance>::Rank>,
    Exp<T::Dimension, <Contracted<V, Ul, Uh> as Variance>::Rank>: ArrayLength<f64>, 

Contracts two indices

The indices must be of opposite types. This is checked at compile time.

impl<T, U> Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    U::Rank: ArrayLength<usize>,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

pub fn iter_coords(&self) -> CoordIterator<U>

Returns an iterator over the coordinates of the tensor.

impl<T, Ul, Ur> Tensor<T, (Ul, Ur)> where
    T: CoordinateSystem,
    Ul: TensorIndex + OtherIndex,
    Ur: TensorIndex + OtherIndex,
    Add1<Ul::Rank>: Unsigned + Add<B1>,
    Add1<Ur::Rank>: Unsigned + Add<B1>,
    Add1<<<Ul as OtherIndex>::Output as Variance>::Rank>: Unsigned + Add<B1>,
    Add1<<<Ur as OtherIndex>::Output as Variance>::Rank>: Unsigned + Add<B1>,
    <(Ul, Ur) as Variance>::Rank: ArrayLength<usize>,
    T::Dimension: Pow<Add1<Ul::Rank>> + Pow<Add1<Ur::Rank>> + ArrayLength<usize>,
    T::Dimension: Pow<Add1<<<Ul as OtherIndex>::Output as Variance>::Rank>>,
    T::Dimension: Pow<Add1<<<Ur as OtherIndex>::Output as Variance>::Rank>>,
    Exp<T::Dimension, Add1<Ul::Rank>>: ArrayLength<f64>,
    Exp<T::Dimension, Add1<Ur::Rank>>: ArrayLength<f64>,
    Exp<T::Dimension, Add1<<<Ul as OtherIndex>::Output as Variance>::Rank>>: ArrayLength<f64>,
    Exp<T::Dimension, Add1<<<Ur as OtherIndex>::Output as Variance>::Rank>>: ArrayLength<f64>, 

pub fn unit(p: Point<T>) -> Tensor<T, (Ul, Ur)>

Returns a unit matrix (1 on the diagonal, 0 everywhere else)

pub fn transpose(&self) -> Tensor<T, (Ur, Ul)>

Transposes the matrix

pub fn inverse(
    &self
) -> Option<Tensor<T, (<Ul as OtherIndex>::Output, <Ur as OtherIndex>::Output)>>

Function calculating the inverse of self using the LU ddecomposition.

The return value is an Option, since self may be non-invertible - in such a case, None is returned

impl<T, U> Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    U::Rank: ArrayLength<usize>,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

pub fn convert<T2>(&self) -> Tensor<T2, U> where
    T2: CoordinateSystem + 'static,
    T2::Dimension: Pow<U::Rank> + Pow<U2> + Same<T::Dimension>,
    Exp<T2::Dimension, U::Rank>: ArrayLength<f64>,
    Exp<T2::Dimension, U2>: ArrayLength<f64>,
    T: ConversionTo<T2>, 

Trait Implementations

impl<T, U, V, Ul, Uh> InnerProduct<Tensor<T, V>, Ul, Uh> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    V: Variance,
    Ul: Unsigned,
    Uh: Unsigned,
    T::Dimension: Pow<U::Rank> + Pow<V::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>,
    Exp<T::Dimension, V::Rank>: ArrayLength<f64>,
    U: Concat<V>,
    Joined<U, V>: Contract<Ul, Uh>,
    <Contracted<Joined<U, V>, Ul, Uh> as Variance>::Rank: ArrayLength<usize>,
    T::Dimension: Pow<<Contracted<Joined<U, V>, Ul, Uh> as Variance>::Rank>,
    Exp<T::Dimension, <Contracted<Joined<U, V>, Ul, Uh> as Variance>::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, Contracted<Joined<U, V>, Ul, Uh>>

fn inner_product(
    self,
    rhs: Tensor<T, V>
) -> Tensor<T, Contracted<Joined<U, V>, Ul, Uh>>

impl<T, U> Copy for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    <T::Dimension as ArrayLength<f64>>::ArrayType: Copy,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>,
    <Exp<T::Dimension, U::Rank> as ArrayLength<f64>>::ArrayType: Copy, 

impl<T, U> Clone for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

fn clone(&self) -> Tensor<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> Add<Tensor<T, U>> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, U>

The resulting type after applying the + operator.

fn add(self, rhs: Tensor<T, U>) -> Tensor<T, U>

Performs the + operation.

impl<T, U> Sub<Tensor<T, U>> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Tensor<T, U>) -> Tensor<T, U>

Performs the - operation.

impl<T, U> Mul<f64> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, U>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Tensor<T, U>

Performs the * operation.

impl<T, U> Mul<Tensor<T, U>> for f64 where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, U>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, U>) -> Tensor<T, U>

Performs the * operation.

impl<T, U, V> Mul<Tensor<T, V>> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    V: Variance,
    U::Rank: ArrayLength<usize>,
    V::Rank: ArrayLength<usize>,
    T::Dimension: Pow<U::Rank> + Pow<V::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>,
    Exp<T::Dimension, V::Rank>: ArrayLength<f64>,
    U: Concat<V>,
    Joined<U, V>: Variance,
    T::Dimension: Pow<<Joined<U, V> as Variance>::Rank>,
    Exp<T::Dimension, <Joined<U, V> as Variance>::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, Joined<U, V>>

The resulting type after applying the * operator.

fn mul(self, rhs: Tensor<T, V>) -> Tensor<T, Joined<U, V>>

Performs the * operation.

impl<T, U> Div<f64> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = Tensor<T, U>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Tensor<T, U>

Performs the / operation.

impl<'a, T, U> Index<&'a [usize]> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = f64

The returned type after indexing.

fn index(&self, idx: &'a [usize]) -> &f64

Performs the indexing (container[index]) operation.

impl<'a, T, U> Index<usize> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

type Output = f64

The returned type after indexing.

fn index(&self, idx: usize) -> &f64

Performs the indexing (container[index]) operation.

impl<'a, T, U> IndexMut<&'a [usize]> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

fn index_mut(&mut self, idx: &'a [usize]) -> &mut f64

Performs the mutable indexing (container[index]) operation.

impl<'a, T, U> IndexMut<usize> for Tensor<T, U> where
    T: CoordinateSystem,
    U: Variance,
    T::Dimension: Pow<U::Rank>,
    Exp<T::Dimension, U::Rank>: ArrayLength<f64>, 

fn index_mut(&mut self, idx: usize) -> &mut f64

Performs the mutable indexing (container[index]) operation.