00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef DJC_COROPA_LIBALGEBRA_TENSORH_SEEN
00019 #define DJC_COROPA_LIBALGEBRA_TENSORH_SEEN
00020
00022
00032 template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
00033 class free_tensor : public algebra<free_tensor_basis<SCA, RAT, n_letters, max_degree> >
00034 {
00035 public:
00037 typedef free_tensor_basis<SCA, RAT, n_letters, max_degree> BASIS;
00039 typedef typename BASIS::KEY KEY;
00041 typedef sparse_vector<BASIS> VECT;
00043 typedef algebra<BASIS> ALG;
00045 typedef typename ALG::iterator iterator;
00047 typedef typename ALG::const_iterator const_iterator;
00048 public:
00050 free_tensor(void) {}
00052 free_tensor(const free_tensor& t)
00053 : ALG(t) {}
00055 free_tensor(const shuffle_tensor<SCA, RAT, n_letters, max_degree>& t)
00056 {
00057 typename shuffle_tensor<SCA, RAT, n_letters, max_degree>::const_iterator i;
00058 for (i = t.begin(); i != t.end(); ++i)
00059 (*this)[i->first] += i->second;
00060 }
00062 free_tensor(const ALG& a)
00063 : ALG(a) {}
00065 free_tensor(const VECT& v)
00066 : ALG(v) {}
00068 free_tensor(LET letter, const SCA& s)
00069 : ALG(VECT::basis.keyofletter(letter), s) {}
00071 explicit free_tensor(const KEY& k)
00072 : ALG(k) {}
00074 explicit free_tensor(const SCA& s)
00075 : ALG(VECT::basis.empty_key, s) {}
00076 public:
00078 inline __DECLARE_BINARY_OPERATOR(free_tensor,*,*=,SCA)
00080 inline __DECLARE_BINARY_OPERATOR(free_tensor,/,/=,RAT)
00082 inline __DECLARE_BINARY_OPERATOR(free_tensor,*,*=,free_tensor)
00084 inline __DECLARE_BINARY_OPERATOR(free_tensor,+,+=,free_tensor)
00086 inline __DECLARE_BINARY_OPERATOR(free_tensor,-,-=,free_tensor)
00088 inline __DECLARE_UNARY_OPERATOR(free_tensor,-,-,ALG)
00090 inline friend free_tensor exp(const free_tensor& arg)
00091 {
00092
00093
00094 static KEY kunit;
00095 free_tensor result(kunit);
00096 for (DEG i = max_degree; i >= 1; --i)
00097 {
00098 result.mul_scal_div(arg, (RAT)i);
00099 result += (free_tensor)kunit;
00100 }
00101 return result;
00102 }
00104 inline friend free_tensor log(const free_tensor& arg)
00105 {
00106
00107
00108
00109
00110
00111 static KEY kunit;
00112 free_tensor tunit(kunit);
00113 free_tensor x(arg);
00114 iterator it = x.find(kunit);
00115 if (it != x.end())
00116 x.erase(it);
00117 free_tensor result;
00118 for (DEG i = max_degree; i >= 1; --i)
00119 {
00120 if (i % 2 == 0)
00121 result.sub_scal_div(tunit, (RAT)i);
00122 else
00123 result.add_scal_div(tunit, (RAT)i);
00124 result *= x;
00125 }
00126 return result;
00127 }
00128 };
00129
00131
00142 template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
00143 class shuffle_tensor : public algebra<shuffle_tensor_basis<SCA, RAT, n_letters, max_degree> >
00144 {
00145 public:
00147 typedef shuffle_tensor_basis<SCA, RAT, n_letters, max_degree> BASIS;
00149 typedef typename BASIS::KEY KEY;
00151 typedef sparse_vector<BASIS> VECT;
00153 typedef algebra<BASIS> ALG;
00155 typedef typename ALG::iterator iterator;
00157 typedef typename ALG::const_iterator const_iterator;
00158 public:
00160 shuffle_tensor(void) {}
00162 shuffle_tensor(const shuffle_tensor& t)
00163 : ALG(t) {}
00165 shuffle_tensor(const free_tensor<SCA, RAT, n_letters, max_degree>& t)
00166 {
00167 typename free_tensor<SCA, RAT, n_letters, max_degree>::const_iterator i;
00168 for (i = t.begin(); i != t.end(); ++i)
00169 (*this)[i->first] += i->second;
00170 }
00172 shuffle_tensor(const ALG& a)
00173 : ALG(a) {}
00175 shuffle_tensor(const VECT& v)
00176 : ALG(v) {}
00178 shuffle_tensor(LET letter, const SCA& s)
00179 : ALG(VECT::basis.keyofletter(letter), s) {}
00181 explicit shuffle_tensor(const KEY& k)
00182 : ALG(k) {}
00184 explicit shuffle_tensor(const SCA& s)
00185 : ALG(VECT::basis.empty_key, s) {}
00186 public:
00188 inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,*,*=,SCA)
00190 inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,/,/=,RAT)
00192 inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,*,*=,shuffle_tensor)
00194 inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,+,+=,shuffle_tensor)
00196 inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,-,-=,shuffle_tensor)
00198 inline __DECLARE_UNARY_OPERATOR(shuffle_tensor,-,-,ALG)
00199 };
00200
00201
00202 #endif // DJC_COROPA_LIBALGEBRA_TENSORH_SEEN
00203
00204