DynInt.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2009 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max Planck Society
 */

#ifndef __DYNINT_H__
#define __DYNINT_H__

#include <shogun/lib/common.h>
#include <shogun/io/SGIO.h>
#include <shogun/mathematics/Math.h>

namespace shogun
{
template <class T, int sz> class CDynInt
{
public:
    CDynInt()
    {
        for (int i=0; i<sz; i++)
            integer[i]=0;
    }

    CDynInt(uint8_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]= (T) x;
    }

    CDynInt(uint16_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]= (T) x;
    }

    CDynInt(uint32_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]= (T) x;
    }

    CDynInt(int32_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]= (T) x;
    }

    CDynInt(int64_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]=(T) x;
    }

    CDynInt(uint64_t x)
    {
        for (int i=0; i<sz-1; i++)
            integer[i]=0;
        integer[sz-1]=(T) x;
    }

    CDynInt(const T x[sz])
    {
        for (int i=0; i<sz; i++)
            integer[i]=x[i];
    }

    CDynInt(const CDynInt<T,sz> &x)
    {
        for (int i=0; i<sz; i++)
            integer[i]=x.integer[i];
    }

    ~CDynInt()
    {
    }

    CDynInt<T,sz>& operator=(const CDynInt<T,sz>& x)
    {
        for (int i=0; i<sz; i++)
            integer[i]=x.integer[i];
        return *this;
    }

    const CDynInt<T,sz> operator|(const CDynInt<T,sz>& x) const
    {
        CDynInt<T,sz> r;

        for (int i=sz-1; i>=0; i--)
            r.integer[i]=integer[i] | x.integer[i];

        return r;
    }

    const CDynInt<T,sz> operator&(const CDynInt<T,sz>& x) const
    {
        CDynInt<T,sz> r;

        for (int i=sz-1; i>=0; i--)
            r.integer[i]=integer[i] & x.integer[i];

        return r;
    }

    CDynInt<T,sz> operator<<(int shift)
    {
        CDynInt<T,sz> r=*this;

        while (shift>0)
        {
            int s=CMath::min(shift, 8*((int) sizeof(T))-1);

            for (int i=0; i<sz; i++)
            {
                T overflow=0;
                if (i<sz-1)
                    overflow = r.integer[i+1] >> (sizeof(T)*8 - s);
                r.integer[i]= (r.integer[i] << s) | overflow;
            }

            shift-=s;
        }

        return r;
    }

    CDynInt<T,sz> operator>>(int shift)
    {
        CDynInt<T,sz> r=*this;

        while (shift>0)
        {
            int s=CMath::min(shift, 8*((int) sizeof(T))-1);

            for (int i=sz-1; i>=0; i--)
            {
                T overflow=0;
                if (i>0)
                    overflow = (r.integer[i-1] << (sizeof(T)*8 - s));
                r.integer[i]= (r.integer[i] >> s) | overflow;
            }

            shift-=s;
        }

        return r;
    }

    const CDynInt<T,sz> operator^(const CDynInt<T,sz>& x) const
    {
        CDynInt<T,sz> r;

        for (int i=sz-1; i>=0; i--)
            r.integer[i]=integer[i] ^ x.integer[i];

        return r;
    }

    const CDynInt<T,sz> operator+(const CDynInt<T,sz> &x) const
    {
        CDynInt<T,sz> r;

        T overflow=0;
        for (int i=sz-1; i>=0; i--)
        {
            r.integer[i]=integer[i]+x.integer[i]+overflow;
            if (r.integer[i] < CMath::max(integer[i], x.integer[i]))
                overflow=1;
            else
                overflow=0;
        }

        return x;
    }

    const CDynInt<T,sz> operator-(const CDynInt<T,sz> &x) const
    {
        return NULL;
    }

    const CDynInt<T,sz> operator/(const CDynInt<T,sz> &x) const
    {
        return NULL;
    }

    const CDynInt<T,sz> operator*(const CDynInt<T,sz> &x) const
    {
        return NULL;
    }

    CDynInt<T,sz>& operator+=(const CDynInt<T,sz> &x)
    {
        return NULL;
    }

    CDynInt<T,sz>& operator-=(const CDynInt<T,sz> &x)
    {
        return NULL;
    }

    CDynInt<T,sz>& operator*=(const CDynInt<T,sz> &x)
    {
        return NULL;
    }

    CDynInt<T,sz>& operator/=(const CDynInt<T,sz> &x)
    {
        return NULL;
    }

    bool operator==(const CDynInt<T,sz> &x) const
    {
        for (int i=sz-1; i>=0; i--)
        {
            if (integer[i]!=x.integer[i])
                return false;
        }

        return true;
    }

    bool operator>=(const CDynInt<T,sz> &x) const
    {
        for (int i=0; i<sz; i++)
        {
            if (integer[i]>x.integer[i])
                return true;
            if (integer[i]<x.integer[i])
                return false;
        }
        return true;
    }

    bool operator<=(const CDynInt<T,sz> &x) const
    {
        for (int i=0; i<sz; i++)
        {
            if (integer[i]<x.integer[i])
                return true;
            if (integer[i]>x.integer[i])
                return false;
        }
        return true;
    }

    bool operator>(const CDynInt<T,sz> &x) const
    {
        for (int i=0; i<sz; i++)
        {
            if (integer[i]>x.integer[i])
                return true;
            if (integer[i]<x.integer[i])
                return false;
        }
        return false;
    }

    bool operator<(const CDynInt<T,sz> &x) const
    {
        for (int i=0; i<sz; i++)
        {
            if (integer[i]<x.integer[i])
                return true;
            if (integer[i]>x.integer[i])
                return false;
        }
        return false;
    }

    bool operator!=(const CDynInt<T,sz> &x) const
    {
        for (int i=sz-1; i>=0; i--)
        {
            if (integer[i]!=x.integer[i])
                return true;
        }
        return false;
    }

    CDynInt<T,sz>& operator|=(const CDynInt<T,sz>& x)
    {
        for (int i=sz-1; i>=0; i--)
            integer[i]|=x.integer[i];

        return *this;
    }

    CDynInt<T,sz>& operator&=(const CDynInt<T,sz>& x)
    {
        for (int i=sz-1; i>=0; i--)
            integer[i]&=x.integer[i];

        return *this;
    }

    CDynInt<T,sz>& operator^=(const CDynInt<T,sz>& x)
    {
        for (int i=sz-1; i>=0; i--)
            integer[i]^=x.integer[i];

        return *this;
    }

    CDynInt<T,sz>& operator<<=(int shift)
    {
        *this=*this<<shift;
        return *this;
    }

    CDynInt<T,sz>& operator>>=(int shift)
    {
        *this=*this>>shift;
        return *this;
    }

    CDynInt<T,sz>& operator~()
    {
        for (int i=sz-1; i>=0; i--)
            integer[i]= ~integer[i];
        return *this;
    }

    operator T() { return integer[sz-1]; }

    CDynInt<T,sz>& operator--()
    {
        T overflow=0;
        for (int i=sz-1; i>=0; i--)
        {
            T x = integer[i]-1-overflow;
            overflow=0;
            if (integer[i]>x)
                overflow=1;
            integer[i]=x;
        }
        return *this;
    }

    CDynInt<T,sz>& operator++()
    {
        T overflow=0;
        for (int i=sz-1; i>=0; i--)
        {
            T x = integer[i]+1+overflow;
            overflow=0;
            if (integer[i]>x)
                overflow=1;
            integer[i]=x;
        }
        return *this;
    }

    void print_hex() const
    {
        for (int i=0; i<sz; i++)
            SG_SPRINT("%.16llx", (uint64_t) integer[i])
    }

    void print_bits() const
    {
        CMath::display_bits(integer, sz);
    }

private:
    T integer[sz];
};


typedef CDynInt<uint64_t,3> uint192_t;

typedef CDynInt<uint64_t,4> uint256_t;

typedef CDynInt<uint64_t,8> uint512_t;

typedef CDynInt<uint64_t,16> uint1024_t;
}
#endif // __DYNINT_H__