libalgebra-demo/libalgebra/utils.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)

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




//  utils.h


// Include once wrapper
#ifndef DJC_COROPA_LIBALGEBRA_UTILSH_SEEN
#define DJC_COROPA_LIBALGEBRA_UTILSH_SEEN

template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
class maps
{
        typedef free_tensor_basis<SCA, RAT, n_letters, max_degree> TBASIS;
        typedef lie_basis<SCA, RAT, n_letters, max_degree> LBASIS;
        typedef typename LBASIS::KEY LKEY;
        typedef typename TBASIS::KEY TKEY;
        typedef lie<SCA, RAT, n_letters, max_degree> LIE;
        typedef free_tensor<SCA, RAT, n_letters, max_degree> TENSOR;
public:
        maps(void) {}
public:
        inline TENSOR exp(LET l)
        {       
                TKEY k; // empty word.
                TENSOR result(k);
                SCA coef(+1);
                DEG i;
                for (i = 1; i <= max_degree; ++i)
                {
                        coef /= (RAT)i;
                        k.push_back(l);
                        result[k] = coef;
                }
                return result;
        }
        inline TENSOR l2t(const LIE& arg)
        {
                TENSOR result;
                typename LIE::const_iterator i;
                for (i = arg.begin(); i != arg.end(); ++i)
                        result.add_scal_prod(expand(i->first), i->second);
                return result;
        }

        inline LIE t2l(const TENSOR& arg)
        {
                LIE result;
                typename TENSOR::const_iterator i;
                for (i = arg.begin(); i != arg.end(); ++i)
                        result.add_scal_prod(rbraketing(i->first), i->second);
                typename LIE::iterator j;
                for (j = result.begin(); j != result.end(); ++j)
                        j->second /= (RAT)LIE::basis.degree(j->first);          
                return result;
        }

        inline const LIE& rbraketing(const TKEY& k)
        {
                static boost::recursive_mutex table_access;
                // get exclusive recursive access for the thread 
                boost::lock_guard<boost::recursive_mutex> lock(table_access); 

                static std::map<TKEY, LIE> lies;
                typename std::map<TKEY, LIE>::iterator it;
                it = lies.find(k);
                if (it == lies.end())
                        return lies[k] = _rbraketing(k);
                else
                        return it->second;
        }

        inline const TENSOR& expand(const LKEY& k)      
        {
                static boost::recursive_mutex table_access;
                // get exclusive recursive access for the thread 
                boost::lock_guard<boost::recursive_mutex> lock(table_access); 

                static std::map<LKEY, TENSOR> table;
                typename std::map<LKEY, TENSOR>::iterator it;
                it = table.find(k);
                if (it == table.end())
                        return table[k] = _expand(k);
                else
                        return it->second;
        }
private:
        TENSOR _expand(const LKEY& k)   
        {
                if (LIE::basis.letter(k))
                        return (TENSOR)TENSOR::basis.keyofletter(LIE::basis.getletter(k));
                return commutator(expand(LIE::basis.lparent(k)),
                        expand(LIE::basis.rparent(k)));
        }
        LIE _rbraketing(const TKEY& k)
        {
                if (TENSOR::basis.letter(k))
                        return (LIE)LIE::basis.keyofletter(TENSOR::basis.getletter(k));
                return rbraketing(TENSOR::basis.lparent(k))
                        * rbraketing(TENSOR::basis.rparent(k));
        }
};

template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
class cbh
{
        typedef free_tensor_basis<SCA, RAT, n_letters, max_degree> TBASIS;
        typedef lie_basis<SCA, RAT, n_letters, max_degree> LBASIS;
        typedef typename LBASIS::KEY LKEY;
        typedef typename TBASIS::KEY TKEY;
        typedef lie<SCA, RAT, n_letters, max_degree> LIE;
        typedef free_tensor<SCA, RAT, n_letters, max_degree> TENSOR;
        typedef maps<SCA, RAT, n_letters, max_degree> MAPS;
public:
        mutable MAPS maps;//TJL added mutable
        TENSOR empty_tensor;
        LIE empty_lie;
public:
        cbh(void) {}
public:
        inline LIE basic(const std::vector<LET>& s) const
        {
                TENSOR tmp(maps.exp(s[0]));
                typename std::string::size_type i;              
                for (i = 1; i < s.size(); ++i)
                        tmp *= maps.exp(s[i]);
                return maps.t2l(log(tmp));
        }
        inline LIE full(const std::vector<LIE*>& lies) const
        {
                typename std::vector<LIE*>::size_type i;
                TENSOR tmp(exp(maps.l2t(*lies[0])));
                for (i = 1; i < lies.size(); ++i)
                        tmp *= exp(maps.l2t(*lies[i]));
                return maps.t2l(log(tmp));
        }
};


// Include once wrapper
#endif // DJC_COROPA_LIBALGEBRA_UTILSH_SEEN

//EOF.