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>
[src]
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>
[src]
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>
[src]
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
Trait Implementations
impl<T, U> Clone for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
fn clone(&self) -> Tensor<T, U>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<T, U> Copy for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, T::Dimension::ArrayType: Copy, Power<T::Dimension, U::Rank>: ArrayLength<f64>, Power<T::Dimension, U::Rank>::ArrayType: Copy
[src]
impl<'a, T, U> Index<&'a [usize]> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = f64
The returned type after indexing
fn index(&self, idx: &'a [usize]) -> &f64
The method for the indexing (Foo[Bar]
) operation
impl<'a, T, U> IndexMut<&'a [usize]> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
fn index_mut(&mut self, idx: &'a [usize]) -> &mut f64
The method for the indexing (Foo[Bar]
) operation
impl<'a, T, U> Index<usize> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = f64
The returned type after indexing
fn index(&self, idx: usize) -> &f64
The method for the indexing (Foo[Bar]
) operation
impl<'a, T, U> IndexMut<usize> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
impl<T, U> Add<Tensor<T, U>> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = Tensor<T, U>
The resulting type after applying the +
operator
fn add(self, rhs: Tensor<T, U>) -> Tensor<T, U>
The method for the +
operator
impl<T, U> Sub<Tensor<T, U>> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = Tensor<T, U>
The resulting type after applying the -
operator
fn sub(self, rhs: Tensor<T, U>) -> Tensor<T, U>
The method for the -
operator
impl<T, U> Mul<f64> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = Tensor<T, U>
The resulting type after applying the *
operator
fn mul(self, rhs: f64) -> Tensor<T, U>
The method for the *
operator
impl<T, U> Div<f64> for Tensor<T, U> where T: CoordinateSystem, U: Variance, T::Dimension: Pow<U::Rank>, Power<T::Dimension, U::Rank>: ArrayLength<f64>
[src]
type Output = Tensor<T, U>
The resulting type after applying the /
operator
fn div(self, rhs: f64) -> Tensor<T, U>
The method for the /
operator
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>, Power<T::Dimension, U::Rank>: ArrayLength<f64>, Power<T::Dimension, V::Rank>: ArrayLength<f64>, U: Concat<V>, Joined<U, V>: Variance, T::Dimension: Pow<Joined<U, V>::Rank>, Power<T::Dimension, Joined<U, V>::Rank>: ArrayLength<f64>
[src]
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>>
The method for the *
operator