RDE_lib2/lietovectorfield.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)

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



#pragma once

#ifndef __lie2vectorfield__
#define __lie2vectorfield__


#include <math.h>
#include "alg_types2.h"



template <typename my_alg_type, typename VF>
class lietovectorfield
{
        typedef typename my_alg_type::LIE LIE;
        typedef typename my_alg_type::S S;
        typedef typename my_alg_type::Q Q;

        static const unsigned DEPTH = my_alg_type::DEPTH;
        static const unsigned myDIM = my_alg_type::myDIM;

        typedef typename alg::lie_basis<S,Q,myDIM,DEPTH> LBASIS;
        typedef typename LBASIS::KEY LKEY;


private:
        std::vector<VF> vecargument;
        std::map<unsigned int, VF> table;

public: 
        lietovectorfield(const std::vector<VF> & vecarg)
                : vecargument(vecarg)
        {
        }

        ~lietovectorfield(void)
        {
        }

        VF lie2vectorfield(const LIE & liearg)
        {
                VF result;
                for (LIE::const_iterator i = liearg.begin(); i != liearg.end(); ++i)
                {
                        VF::scaled_add(expand(i->first),(double) i->second, result); 
                }
                return result;
        }

        VF expand(const LKEY & k)
        {
                std::map<unsigned int, VF>::iterator it;
                it = table.find(k);
                if (it == table.end())
                {
                        return table[k] = rec_expand(k);
                }
                else 
                {
                        return it->second;
                }
        }

private:
        VF rec_expand(const LKEY & k)
        {
                if (LIE::basis.letter(k)) 
                {
                        return (VF) vecargument[k-1];
                }
                else
                {
                        return VF::Lie(expand( LIE::basis.lparent(k)), expand( LIE::basis.rparent(k)));
                }
        }

};



#endif // __lie2vectorfield__