Provided by: librheolef-dev_7.2-2_amd64 bug


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


       The tensor class defines a d*d matrix with floating coefficients. This class is suitable
       for defining tensors, i.e. field(2) with d*d matrix values at each physical position.

       It is represented as a bidimensional array of coordinates. The coordinate indexes start at
       zero and finishes at d-1, e.g. a(0,0), a(0,1), ..., a(2,2).

       The default constructor set all components to zero:

           tensor a;

        and this default could be overridden:

           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.


       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 {

         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>
       std::istream& operator>> (std::istream& in, tensor_basic<T>& a) {
           return a.get (in); }

       template<class T>
       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);


       Pierre  Saramito  <>


       Copyright   (C)  2000-2018  Pierre  Saramito  <> GPLv3+: GNU GPL
       version 3 or later  <>.  This  is  free  software:  you
       are free to change and redistribute it.  There is NO WARRANTY, to the extent permitted by