libalgebra-demo/libalgebra/tensor.h

/* *************************************************************

Copyright 2010 Terry Lyons, Stephen Buckley, Djalil Chafai, 
Greg Gyurkó and Arend Janssen. 

Distributed under the terms of the GNU General Public License, 
Version 3. (See accompanying file License.txt)

************************************************************* */




//  tensor.h


// Include once wrapper
#ifndef DJC_COROPA_LIBALGEBRA_TENSORH_SEEN
#define DJC_COROPA_LIBALGEBRA_TENSORH_SEEN


template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
class free_tensor : public algebra<free_tensor_basis<SCA, RAT, n_letters, max_degree> >
{
public:
        typedef free_tensor_basis<SCA, RAT, n_letters, max_degree> BASIS;
        typedef typename BASIS::KEY KEY;
        typedef sparse_vector<BASIS> VECT;
        typedef algebra<BASIS> ALG;
        typedef typename ALG::iterator iterator;
        typedef typename ALG::const_iterator const_iterator;
public:
        free_tensor(void) {}
        free_tensor(const free_tensor& t)
                : ALG(t) {}
        free_tensor(const shuffle_tensor<SCA, RAT, n_letters, max_degree>& t)
        {
                typename shuffle_tensor<SCA, RAT, n_letters, max_degree>::const_iterator i;
                for (i = t.begin(); i != t.end(); ++i)
                        (*this)[i->first] += i->second;
        }
        free_tensor(const ALG& a)
                : ALG(a) {}
        free_tensor(const VECT& v)
                : ALG(v) {}     
        free_tensor(LET letter, const SCA& s)
                : ALG(VECT::basis.keyofletter(letter), s) {}
        explicit free_tensor(const KEY& k)
                : ALG(k) {}
        explicit free_tensor(const SCA& s)
                : ALG(VECT::basis.empty_key, s) {}
public:
  inline __DECLARE_BINARY_OPERATOR(free_tensor,*,*=,SCA)
  inline __DECLARE_BINARY_OPERATOR(free_tensor,/,/=,RAT)
  inline __DECLARE_BINARY_OPERATOR(free_tensor,*,*=,free_tensor)
  inline __DECLARE_BINARY_OPERATOR(free_tensor,+,+=,free_tensor)
  inline __DECLARE_BINARY_OPERATOR(free_tensor,-,-=,free_tensor)
  inline __DECLARE_UNARY_OPERATOR(free_tensor,-,-,ALG)
        inline friend free_tensor exp(const free_tensor& arg)
        {
                // Computes the truncated exponential of arg
                // 1 + arg + arg^2/2! + ... + arg^n/n! where n = max_degree
                static KEY kunit;
                free_tensor result(kunit);
                for (DEG i = max_degree; i >= 1; --i)
                {
                        result.mul_scal_div(arg, (RAT)i);
                        result += (free_tensor)kunit;
                }
                return result;
        }
        inline friend free_tensor log(const free_tensor& arg)
        {
                // Computes the truncated log of arg up to degree max_degree
                // The coef. of the constant term (empty word in the monoid) of arg 
                // is forced to 1.
                // log(arg) = log(1+x) = x - x^2/2 + ... + (-1)^(n+1) x^n/n.
                // max_degree must be > 0
                static KEY kunit;
                free_tensor tunit(kunit);
                free_tensor x(arg);
                iterator it = x.find(kunit);
                if (it != x.end())
                        x.erase(it);
                free_tensor result;
                for (DEG i = max_degree; i >= 1; --i)
                {
                        if (i % 2 == 0)
                                result.sub_scal_div(tunit, (RAT)i);
                        else
                                result.add_scal_div(tunit, (RAT)i);
                        result *= x;
                }
                return result;
        }
};


template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
class shuffle_tensor : public algebra<shuffle_tensor_basis<SCA, RAT, n_letters, max_degree> >
{
public:
        typedef shuffle_tensor_basis<SCA, RAT, n_letters, max_degree> BASIS;
        typedef typename BASIS::KEY KEY;
        typedef sparse_vector<BASIS> VECT;
        typedef algebra<BASIS> ALG;
        typedef typename ALG::iterator iterator;
        typedef typename ALG::const_iterator const_iterator;
public:
        shuffle_tensor(void) {}
        shuffle_tensor(const shuffle_tensor& t)
                : ALG(t) {}
        shuffle_tensor(const free_tensor<SCA, RAT, n_letters, max_degree>& t)
        {
                typename free_tensor<SCA, RAT, n_letters, max_degree>::const_iterator i;
                for (i = t.begin(); i != t.end(); ++i)
                        (*this)[i->first] += i->second;
        }
        shuffle_tensor(const ALG& a)
                : ALG(a) {}
        shuffle_tensor(const VECT& v)
                : ALG(v) {}     
        shuffle_tensor(LET letter, const SCA& s)        
                : ALG(VECT::basis.keyofletter(letter), s) {}
        explicit shuffle_tensor(const KEY& k)
                : ALG(k) {}
        explicit shuffle_tensor(const SCA& s)   
                : ALG(VECT::basis.empty_key, s) {}
public:
  inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,*,*=,SCA)
  inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,/,/=,RAT)
  inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,*,*=,shuffle_tensor)
  inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,+,+=,shuffle_tensor)
  inline __DECLARE_BINARY_OPERATOR(shuffle_tensor,-,-=,shuffle_tensor)
  inline __DECLARE_UNARY_OPERATOR(shuffle_tensor,-,-,ALG)
};

// Include once wrapper
#endif // DJC_COROPA_LIBALGEBRA_TENSORH_SEEN

//EOF.