tensor(2rheolef)

🎀 tensor — d-dimensional physical tensor (rheolef-7.2) 💅

okay bestie, this is tensor(2rheolef) from the rheolef manual (that's the manual name, it's giving section 2, it's giving library docs) and we are about to understand her. buckle up. 🦋

---

✨ NAME ✨

tensor — d-dimensional physical tensor (rheolef-7.2) 👑

---

🌸 DESCRIPTION 🌸

So the tensor class defines a d*d matrix with floating coefficients. She's exactly the right girl for defining tensors, i.e. a field(2) with d*d matrix values at each physical position. no cap. 🫶

She's represented as a bidimensional array of coordinates. The coordinate indexes start at zero and finish at d-1, e.g. a(0,0), a(0,1), ..., a(2,2). lowkey elegant.

The default constructor sets all components to zero:

tensor a;

and this default could be overridden, like:

tensor a = {{1, 2, 3.14},
            {2, 6, 6.2 },
            {5, 8, 9.0 }};

The standard linear algebra with scalars, vectors of R^3 (see the point(2) class) and tensor is supported. 💖

The computation of eigenvalues and eigenvectors, together with the SVD decomposition, are also provided for convenience. she does it all fr fr.

---

💜 IMPLEMENTATION 💜

This documentation has been generated from file fem/geo_element/tensor.h 📁

The tensor class is simply an alias to the tensor_basic class:

typedef tensor_basic<Float> tensor;

The tensor_basic class is a template class with the floating type as parameter:

template<class T>
class tensor_basic {
public:

  typedef size_t size_type;
  typedef T      element_type;
  typedef T      float_type;

// allocators:

  tensor_basic (const T& init_val = 0);
  tensor_basic (T x[3][3]);
  tensor_basic (const tensor_basic<T>& a);
  static tensor_basic<T> eye (size_type d = 3);

  tensor_basic (const std::initializer_list<std::initializer_list<T> >& il);

// affectation:

  tensor_basic<T>& operator= (const tensor_basic<T>& a);
  tensor_basic<T>& operator= (const T& val);

// modifiers:

  void fill (const T& init_val);
  void reset ();
  void set_row    (const point_basic<T>& r, size_t i, size_t d = 3);
  void set_column (const point_basic<T>& c, size_t j, size_t d = 3);

// accessors:

  T& operator()(size_type i, size_type j);
  const T& operator()(size_type i, size_type j) const;
  point_basic<T>  row(size_type i) const;
  point_basic<T>  col(size_type i) const;
  size_t nrow() const; // = 3, for template matrix compatibility
  size_t ncol() const;

// inputs/outputs:

  std::ostream& put (std::ostream& s, size_type d = 3) const;
  std::istream& get (std::istream&);

// algebra:

  bool operator== (const tensor_basic<T>&) const;
  bool operator!= (const tensor_basic<T>& b) const { return ! operator== (b); }
  const tensor_basic<T>& operator+ () const { return *this; }
  tensor_basic<T> operator- () const;
  tensor_basic<T> operator+ (const tensor_basic<T>& b) const;
  tensor_basic<T> operator- (const tensor_basic<T>& b) const;
  tensor_basic<T> operator* (const tensor_basic<T>& b) const;
  tensor_basic<T> operator* (const T& k) const;
  tensor_basic<T> operator/ (const T& k) const;
  point_basic<T>  operator* (const point_basic<T>&) const;
  point_basic<T>  trans_mult (const point_basic<T>& x) const;
  tensor_basic<T>& operator+= (const tensor_basic<T>&);
  tensor_basic<T>& operator-= (const tensor_basic<T>&);
  tensor_basic<T>& operator*= (const T& k);
  tensor_basic<T>& operator/= (const T& k);

  T determinant (size_type d = 3) const;
  bool is_symmetric (size_type d = 3) const;

// eigenvalues & eigenvectors:

  // a = q*d*q^T
  // a may be symmetric
  // where q=(q1,q2,q3) are eigenvectors in rows (othonormal matrix)
  // and   d=(d1,d2,d3) are eigenvalues, sorted in decreasing order d1 >= d2 >= d3
  // return d
  point_basic<T> eig (tensor_basic<T>& q, size_t dim = 3) const;
  point_basic<T> eig (size_t dim = 3) const;

// singular value decomposition:

  // a = u*s*v^T
  // a can be unsymmetric
  // where u=(u1,u2,u3) are left pseudo-eigenvectors in rows (othonormal matrix)
  //       v=(v1,v2,v3) are right pseudo-eigenvectors in rows (othonormal matrix)
  // and   s=(s1,s2,s3) are eigenvalues, sorted in decreasing order s1 >= s2 >= s3
  // return s
  point_basic<T> svd (tensor_basic<T>& u, tensor_basic<T>& v, size_t dim = 3) const;

};

The linear algebra is completed by some classical operators and the matrix exponential 🌈:

template <class U>
point_basic<U>  operator* (const point_basic<U>& yt, const tensor_basic<U>& a);

template <class U>
tensor_basic<U> trans (const tensor_basic<U>& a, size_t d = 3);

template <class U>
void prod (const tensor_basic<U>& a, const tensor_basic<U>& b, tensor_basic<U>& result,
        size_t di=3, size_t dj=3, size_t dk=3);

// tr(a) = a00 + a11 + a22
template <class U>
U tr (const tensor_basic<U>& a, size_t d=3);

template <class U>
U ddot (const tensor_basic<U>&, const tensor_basic<U>&);

// a = u otimes v <==> aij = ui*vj
template <class U>
tensor_basic<U> otimes (const point_basic<U>& u, const point_basic<U>& v, size_t d=3);

template <class U>
tensor_basic<U> inv  (const tensor_basic<U>& a, size_t d = 3);

template <class U>
tensor_basic<U> diag (const point_basic<U>& d);
template <class U>
point_basic<U> diag (const tensor_basic<U>& a);

template <class U>
U determinant (const tensor_basic<U>& A, size_t d = 3);

template <class U>
bool invert_3x3 (const tensor_basic<U>& A, tensor_basic<U>& result);

// matrix exponential:
template<class T>
tensor_basic<T> exp (const tensor_basic<T>& a, size_t d = 3);

// inputs/outputs:
template<class T>
inline
std::istream& operator>> (std::istream& in, tensor_basic<T>& a) {
    return a.get (in); }

template<class T>
inline
std::ostream& operator<< (std::ostream& out, const tensor_basic<T>& a) {
    return a.put (out); }

// t += a otimes b
template<class T>
void cumul_otimes (tensor_basic<T>& t, const point_basic<T>& a, const point_basic<T>& b, size_t na = 3);

template<class T>
void cumul_otimes (tensor_basic<T>& t, const point_basic<T>& a, const point_basic<T>& b, size_t na, size_t nb);

---

👑 AUTHOR 👑

Pierre Saramito <Pierre.Saramito@imag.fr> — the icon who wrote her 💅

---

💖 COPYRIGHT 💖

Copyright (C) 2000-2018 Pierre Saramito <Pierre.Saramito@imag.fr>

GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.

This is free software: you are free to change and redistribute it.

There is NO WARRANTY, to the extent permitted by law. 😭 read it and weep bestie, no warranty fr.

---

and that's the whole page, no notes. this was rheolef Version 7.2 and yes she's a tensor(2rheolef) girlie through and through. periodt. 💅✨🦋🎀