RDE_lib2/BasePath.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 __BASEPATH__
#define __BASEPATH__


#include "dyadic_interval.h"
#include <deque>



template <typename my_alg_type>
class BasePath
{
protected:
        typedef typename my_alg_type::LIE LIE;
        typedef typename my_alg_type::MAPS MAPS;
        typedef typename my_alg_type::CBH CBH;
        typedef typename my_alg_type::SCA SCA;
        typedef typename my_alg_type::S S;

        static const unsigned myDIM = my_alg_type::myDIM;

public:
        BasePath(void){};
        virtual ~BasePath(void){};


        LIE virtual DescribePath(const dyadic_interval &increment, const int accuracy) const = 0 
        {
                return LIE();
        };

        LIE DescribePath(const dyadic_interval &increment) const 
        { 
                return DescribePath(increment, increment.n);
        };

        LIE virtual DescribePath(double inf, double sup, int tolerance) const
        /* Describes a Brownian Path across a real interval */ 
        /* resolving the interval and the path used in the */ 
        /* computation to a level of time 2^(-_iAccuracy) */
        {
                std::deque<dyadic_interval> stack =  dyadic_interval::to_dyadic_intervals(inf, sup, tolerance);
                std::vector <LIE > incs;
                std::vector <LIE* > pincs;
                for (std::deque<dyadic_interval>::iterator it = stack.begin(); it != stack.end();++it)
                {
                        LIE temp = DescribePath(*it, tolerance);
                        incs.push_back(temp);
                        pincs.push_back(& incs.back());
                }
                return LibAlgCBH.full(pincs);
        };

private:
        // an object for manipulating LIE elements
        // LIE LibAlgCBH.full(std::vector<LIE>) 
        // computes the campbell hausdorff product of the vector
        CBH LibAlgCBH;

};

#endif // __BASEPATH__