Struct diffgeom::tensors::Tensor
[−]
[src]
pub struct Tensor<T: CoordinateSystem, U: Variance> where T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64> {
// some 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>, Power<T::Dimension, V::Rank>: ArrayLength<f64>
fn get_point(&self) -> &Point<T>
Returns the point at which the tensor is defined.
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.
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].
fn get_rank() -> usize
Returns the rank of the tensor
fn get_num_coords() -> usize
Returns the number of coordinates of the tensor (equal to [Dimension][Rank])
fn new(point: Point<T>) -> Tensor<T, V>
Creates a new, zero tensor at a given point
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.
fn trace<Ul, Uh>(&self) -> Tensor<T, Contracted<V, Ul, Uh>> where Ul: Unsigned, Uh: Unsigned, V: Contract<Ul, Uh>, Contracted<V, Ul, Uh>::Rank: ArrayLength<usize>, T::Dimension: Pow<Contracted<V, Ul, Uh>::Rank>, Power<T::Dimension, Contracted<V, Ul, Uh>::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>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
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<U1>, Add1<Ur::Rank>: Unsigned + Add<U1>, Add1<Ul::Output::Rank>: Unsigned + Add<U1>, Add1<Ur::Output::Rank>: Unsigned + Add<U1>, (Ul, Ur)::Rank: ArrayLength<usize>, T::Dimension: Pow<Add1<Ul::Rank>> + Pow<Add1<Ur::Rank>> + ArrayLength<usize>, T::Dimension: Pow<Add1<Ul::Output::Rank>>, T::Dimension: Pow<Add1<Ur::Output::Rank>>, Power<T::Dimension, Add1<Ul::Rank>>: ArrayLength<f64>, Power<T::Dimension, Add1<Ur::Rank>>: ArrayLength<f64>, Power<T::Dimension, Add1<Ul::Output::Rank>>: ArrayLength<f64>, Power<T::Dimension, Add1<Ur::Output::Rank>>: ArrayLength<f64>
fn unit(p: Point<T>) -> Tensor<T, (Ul, Ur)>
Returns a unit matrix (1 on the diagonal, 0 everywhere else)
fn transpose(&self) -> Tensor<T, (Ur, Ul)>
Transposes the matrix
fn inverse(&self) -> Option<Tensor<T, (Ul::Output, Ur::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