RDE_lib2/dyadic.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 __DYADIC__
#define __DYADIC__


#include <cmath> // ldexp() frexp() floor()
#include <limits.h> // INT_MAX


class dyadic
{
public:

        dyadic(void)
                : k(0)
                , n(0)
        {
        }

        dyadic(const int k1, const int n1)
                : k(k1)
                , n(n1)
        {
        }

        ~dyadic(void)
        {
        }

        int k;
        int n;

        operator double() const
        {
                return ldexp((double)k,-n);
        }

        explicit dyadic(const double Arg, const unsigned int RelativeTolerance = 1024)
        {
                if (Arg==0)
                {
                        n=INT_MAX;
                        k=0;
                }
                else
                {
        int index = RelativeTolerance;
                double temp = frexp(Arg,&n);
                n = - n;
                k = (int) floor(ldexp(temp,index));
                n+=index;
                }
        }

        dyadic & move_forward(const unsigned int Arg)
        {
                k+=Arg;
                return *this;
        }

        dyadic & operator ++ ()
        {
                ++k;
                return *this;
        }

        dyadic operator ++ (int )
        {
                dyadic temp = *this;
                ++*this;
                return temp;
        }

        dyadic & operator -- ()
        {
                --k;
                return *this;
        }

        dyadic operator -- (int )
        {
                dyadic temp = *this;
                --*this;
                return temp;
        }

        dyadic operator + (const dyadic & Arg) const 
        { 
                dyadic Ans;
                return (n <= Arg.n)? dyadic(k + (Arg.k << (Arg.n-n)),n) : dyadic(Arg.k + (k << (n-Arg.n),Arg.n));
        }
        dyadic & operator += (const dyadic & Arg) 
        {
                return *this=(*this + Arg);
        }
        dyadic operator - (const dyadic & Arg) const 
        {
                dyadic Ans;
                return (n <= Arg.n)? dyadic(k - (Arg.k << (Arg.n-n)),n) : dyadic(((k << (n-Arg.n))- Arg.k,Arg.n));
        }
        dyadic & operator -= (const dyadic & Arg) 
        {
                return *this=(*this - Arg);
        }
        bool operator < (const dyadic & Arg) const 
        {
                return (n <= Arg.n)? (k < (Arg.k << (Arg.n-n))) : (k << (n-Arg.n))< Arg.k;
        }
        bool operator > (const dyadic & Arg) const 
        {
                return (n <= Arg.n)? (k > (Arg.k << (Arg.n-n))) : (k << (n-Arg.n))> Arg.k;
        }

};

#endif // __DYADIC__