RDE_lib2/GroupElement.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 __GROUPELEMENT__
#define __GROUPELEMENT__


#include "AbstractSolutionPoint.h"



template <typename my_alg_type>
class ActionPoint : public my_alg_type::mtlVector
{
        typedef typename my_alg_type::LET LET;
        typedef typename my_alg_type::mtlVector mtlVector;

        static const unsigned myDIM = my_alg_type::myDIM;

public:
        ActionPoint(mtlVector & M) : mtlVector(M){};

        template <typename T>
        ActionPoint(T M) : mtlVector((mtlVector)M){};

        ActionPoint() : mtlVector(myDIM){};

        ~ActionPoint() {};

        explicit ActionPoint (AbstractSolutionPoint<my_alg_type> & p) : mtlVector(myDIM)
        {
                for(unsigned int i=0; i < myDIM; i++)
                {
                        if (p.find(LET(i+1)) != p.end())
                        {
                                (*this)[i] = p[LET(i+1)];
                        }
                        else
                        {
                                (*this)[i] = 0;
                        }
                }
        };

        AbstractSolutionPoint<my_alg_type> ActionPoint2AbstractSolutionPoint(void) 
        {
                AbstractSolutionPoint<my_alg_type> result;

                for(unsigned int i=0; i < myDIM; i++)
                {
                        if ( (*this)[i] != 0 )
                        {
                                result[LET(i+1)] = (*this)[i];
                        }
                }

                return result;
        };

        static ActionPoint<my_alg_type> AbstractSolutionPoint2ActionPoint(AbstractSolutionPoint<my_alg_type> & p)
        {
                ActionPoint<my_alg_type> a;

                for(unsigned int i=0; i < myDIM; i++)
                {
                        if (p.find(LET(i+1)) != p.end())
                        {
                                a[i] = p[LET(i+1)];
                        }
                        else
                        {
                                a[i] = 0;
                        }
                }

                return a;
        };

};// END CLASS DEFINITION ActionPoint



template <typename my_alg_type>
class GroupElement : public  my_alg_type::mtlMatrix
{
        typedef typename my_alg_type::RAT RAT;
        typedef typename my_alg_type::mtlMatrix mtlMatrix;

        static const unsigned myDIM = my_alg_type::myDIM;

public:
        GroupElement(mtlMatrix & M) : mtlMatrix(M) {};

        GroupElement() : mtlMatrix(myDIM,myDIM)
        {
                mtl::set_diagonal((mtlMatrix &)*this,RAT(1));
        };

        ~GroupElement() {};

        GroupElement<my_alg_type> operator* (const GroupElement<my_alg_type> & g) const
        {
        GroupElement<my_alg_type> temp;
        mtl::set_diagonal((mtlMatrix) temp,RAT(0));
        mtl::mult((mtlMatrix &) g,(mtlMatrix &) *this  ,(mtlMatrix &) temp);
        return temp;
        };

        ActionPoint<my_alg_type> operator()(const ActionPoint<my_alg_type> & Arg)
        {
        ActionPoint<my_alg_type> temp;
        mtl::set_value(temp,RAT(0));
        mtlMatrix trans;
        mtl::mult((mtlMatrix &) *this,Arg,temp);
        return ActionPoint<my_alg_type>(temp);
        };

};// END CLASS DEFINITION GroupElement


#endif // __GROUPELEMENT__