RDE_lib2/DataTree.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 DataTree_h__
#define DataTree_h__


#include <dyadic_interval.h>
#include <map>

template <typename my_alg_type>
class Increment;


template <typename my_alg_type>
class FamilyConnections
{
        typedef std::map < dyadic_interval, Increment<my_alg_type> > DataTree;

public:         
        typename DataTree::iterator 
                mitParent, 
                mitSibling;

        FamilyConnections(
                const typename DataTree::iterator itParent , 
                const typename DataTree::iterator itSibling 
                ): mitParent( itParent ), mitSibling( itSibling )
        {
        }
};


template <typename my_alg_type>
class Increment : public FamilyConnections<my_alg_type>
{
        typedef typename my_alg_type::TENSOR TENSOR;
        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::RAT RAT;
        typedef typename my_alg_type::S S;
        typedef typename my_alg_type::Q Q;
        typedef typename my_alg_type::DEG DEG;
        typedef typename my_alg_type::LET LET;

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

protected:
        LIE _LieValue;
        
        int _iAccuracy;
        

public:
        Increment(
                const dyadic_interval inc = dyadic_interval(), 
                typename DataTree::iterator itParent = DataTree::iterator(), 
                typename DataTree::iterator itSibling = DataTree::iterator() 
                ) 
                : FamilyConnections<my_alg_type>( itParent , itSibling ),_LieValue(),_iAccuracy(inc.n)          
        {
        }

        const LIE& LieValue() const { return _LieValue; } // needed to preserve external const-ness
        LIE& LieValue() { return _LieValue; } // needed because CBH is not const 
        
        void LieValue(LIE val) { _LieValue = val; }
        
        int Accuracy() const { return _iAccuracy; }
        
        void Accuracy(int val) { _iAccuracy = val; }
        

        static bool IsLeaf(const typename DataTree::const_iterator & itIncDescriptor)
        {
                const dyadic_interval & 
                        diIncDescriptor = (itIncDescriptor->first);
                const Increment<my_alg_type> & 
                        nvIncDescriptor = (itIncDescriptor->second);
                return nvIncDescriptor.Accuracy()==diIncDescriptor.n;
        }
};

#endif // DataTree_h__