Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
<tt>tensor</tt>

d-dimensional physical tensor

Description

The tensor class defines a d*d matrix with floating coefficients. This class is suitable for defining tensors, i.e. field 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 class) and tensor is supported.

The computation of eigenvalues and eigenvectors, together with the SVD decomposition are also provided for convenience.

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;
see the tensor page for the full documentation

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:
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;
field::size_type size_type
Definition branch.cc:430
std::ostream & put(std::ostream &s, size_type d=3) const
Definition tensor.cc:37
T & operator()(size_type i, size_type j)
Definition tensor.h:335
tensor_basic< T > & operator=(const tensor_basic< T > &a)
Definition tensor.h:303
std::istream & get(std::istream &)
Definition tensor.cc:51
point_basic< T > trans_mult(const point_basic< T > &x) const
Definition tensor.h:367
tensor_basic< T > & operator+=(const tensor_basic< T > &)
Definition tensor.cc:174
point_basic< T > col(size_type i) const
Definition tensor.cc:323
T determinant(size_type d=3) const
Definition tensor.cc:288
tensor_basic< T > & operator*=(const T &k)
Definition tensor.cc:192
tensor_basic< T > operator*(const tensor_basic< T > &b) const
Definition tensor.cc:270
bool is_symmetric(size_type d=3) const
Definition tensor.cc:351
point_basic< T > eig(tensor_basic< T > &q, size_t dim=3) const
Definition tensor.cc:426
const tensor_basic< T > & operator+() const
Definition tensor.h:136
tensor_basic< T > operator-() const
Definition tensor.cc:110
tensor_basic< T > operator/(const T &k) const
Definition tensor.h:360
size_t ncol() const
Definition tensor.h:328
void fill(const T &init_val)
Definition tensor.h:252
bool operator!=(const tensor_basic< T > &b) const
Definition tensor.h:135
size_t nrow() const
Definition tensor.h:321
void set_row(const point_basic< T > &r, size_t i, size_t d=3)
Definition tensor.h:435
tensor_basic< T > & operator-=(const tensor_basic< T > &)
Definition tensor.cc:183
bool operator==(const tensor_basic< T > &) const
Definition tensor.cc:101
tensor_basic< T > & operator/=(const T &k)
Definition tensor.cc:201
point_basic< T > row(size_type i) const
Definition tensor.cc:313
point_basic< T > svd(tensor_basic< T > &u, tensor_basic< T > &v, size_t dim=3) const
Definition tensor.cc:470
void set_column(const point_basic< T > &c, size_t j, size_t d=3)
Definition tensor.h:427
Expr1::float_type T
Definition field_expr.h:230
solver_basic< Float > eye()
see the eye page for the full documentation
Definition eye.h:74
Definition leveque.h:25
};

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);
tensor_basic< T > inv(const tensor_basic< T > &a, size_t d)
Definition tensor.cc:219
tensor_basic< U > otimes(const point_basic< U > &u, const point_basic< U > &v, size_t d=3)
T ddot(const tensor_basic< T > &a, const tensor_basic< T > &b)
ddot(x,y): see the expression page for the full documentation
Definition tensor.cc:278
U tr(const tensor_basic< U > &a, size_t d=3)
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
U determinant(const tensor_basic< U > &A, size_t d=3)
void prod(const tensor_basic< T > &a, const tensor_basic< T > &b, tensor_basic< T > &result, size_t di, size_t dj, size_t dk)
Definition tensor.cc:256
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
csr< T, M > diag(const vec< T, M > &d)
Definition csr.cc:56
void cumul_otimes(tensor_basic< T > &t, const point_basic< T > &a, const point_basic< T > &b, size_t na, size_t nb)
Definition tensor.cc:305
csr< T, sequential > trans(const csr< T, sequential > &a)
trans(a): see the form page for the full documentation
Definition csr.h:455
csr< T, sequential > operator*(const T &lambda, const csr< T, sequential > &a)
Definition csr.h:437
bool invert_3x3(const tensor_basic< T > &A, tensor_basic< T > &result)
Definition tensor.cc:333