.\"
.de Id
..
.de Sp
.if n .sp
.if t .sp 0.4
..
.TH tensor4 2rheolef "rheolef-6.7" "rheolef-6.7" "rheolef-6.7"
.\" label: /*Class:tensor4
.SH NAME
\fBtensor4\fP - a fouth order tensor
.\" skip: @cindex tensor4
.\" skip: @clindex tensor4
.SH SYNOPSYS

The \fBtensor4\fP class defines a fourth tensor where
indices varie from zero to 2 (aka 3D physical space).
.\" END
.SH IMPLEMENTATION
.\" begin_example
.Sp
.nf
template<class T>
class tensor4_basic {
public:

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

// allocators:

  tensor4_basic ();
  explicit tensor4_basic (const T& init_val);
  tensor4_basic (const tensor4_basic<T>& a);
  static tensor4_basic<T> eye (size_type d = 3);

#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_LIST
        tensor4_basic (const std::initializer_list<std::initializer_list<
                             std::initializer_list<std::initializer_list<T> > > >& il);
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_LIST

// affectation:

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

// accessors:

  T&       operator()(size_type i, size_type j, size_type k, size_type l);
  const T& operator()(size_type i, size_type j, size_type k, size_type l) const;

  tensor_basic<T>&  operator()(size_type i, size_type j);
  const tensor_basic<T>& operator()(size_type i, size_type j) const;

// algebra:

  tensor4_basic<T>& operator*= (const T& k);
  tensor4_basic<T>& operator/= (const T& k) { return operator*= (1./k); }
  tensor4_basic<T>  operator* (const T& k) const;
  tensor4_basic<T>  operator/ (const T& k) const;
  tensor4_basic<T>  operator+ (const tensor4_basic<T>& b) const;
  tensor4_basic<T>  operator- (const tensor4_basic<T>& b) const;

// io:
  std::ostream& put (std::ostream& out, size_type d=3) const;

// data:
protected:
  tensor_basic<tensor_basic<T> > _x;
};
typedef tensor4_basic<Float> tensor4;

// nonlinear algebra:
template <class T>
T norm2 (const tensor4_basic<T>&);
template <class T>
T norm (const tensor4_basic<T>& a) { return sqrt(norm2(a)); }
template <class T>
tensor4_basic<T> dexp (const tensor_basic<T>& a, size_t d = 3);

// algebra:
template <class T>
tensor_basic<T> ddot (const tensor4_basic<T>&, const tensor_basic<T>&);
template <class T>
tensor_basic<T> ddot (const tensor_basic<T>&, const tensor4_basic<T>&);
.Sp
.fi
.\" end_example