TnbLongInteger.h

[詳解]

#pragma once
#include "TnbComparable.h"
#include "TnbSerializer.h"
#include "TnbStr.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<size_t PLACE = 8>
class CLongIntegerT : public IComparableT< TNB::CLongIntegerT<PLACE> >, public ISerializable
{
public:
    
    CLongIntegerT(void)
    {
        Zero();
    }
 
    CLongIntegerT(const CLongIntegerT& other)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] = other.m_num[i];
        }
    }
 
    CLongIntegerT(LONGLONG val)
    {
        operator=(val);
    }
 
    void Zero(void)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] = 0;
        }
    }
 
    size_t SetString(LPCTSTR lpsz)
    {
        Zero();
        CStr str = lpsz;
        size_t len = str.GetLength();
        bool isMinus = false;
        loop ( i, len )
        {
            if ( i == 0 && str[i] == '-' )
            {
                isMinus = true;
            }
            else if ( str[i] < '0' || str[i] > '9' )
            {
                len = i;
                break;
            }
        }
        size_t ret = len;
        if ( isMinus )
        {
            len--;
            str = str.Mid(1, len);
        }
        else
        {
            str = str.Left(len);
        }
        INDEX cnt = 0;
        while ( len > 0 )
        {
            CStr s = str.Right(9);
            CLongIntegerT x(s.ToInt());
            loop ( i, cnt )
            {
                x *= INT_VALUE_MAX;
            }
            operator+=(x);
            len -= s.GetLength();
            str = str.Left(len);
            cnt++;
        }
        if ( isMinus )
        {
            *this = operator-();
        }
        return ret;
    }
 
    size_t SetHexString(LPCTSTR lpsz)
    {
        Zero();
        size_t len = STRLIB::GetLen(lpsz);
        loop ( i, len )
        {
            if ( STRLIB::HexCharToInt(lpsz[i]) < 0 )
            {
                len = i;
                break;
            }
        }
        loop( i, len )
        {
            size_t j = i / 8;
            if ( j >= DWORD_LEN )
            {
                break;
            }
            int c = STRLIB::HexCharToInt(lpsz[len - 1 - i]);
            DWORD k = (c & 0xFF) << ((i & 7) * 4);
            m_num[j] |= k;
        }
        return len;
    }
 
    void SetRawData(size_t size, LPCVOID lpRawData)
    {
        Zero();
        if ( size > BYTE_LEN )
        {
            size = BYTE_LEN;
        }
        const BYTE* P1 = static_cast<const BYTE*>(lpRawData);
        BYTE* P2 = reinterpret_cast<BYTE*>(m_num);
        loop ( i, size )
        {
            *P2++ = *P1++;
        }
    }
 
    void GetRawData(CWorkMem& _rawData) const
    {
        _rawData.Resize(BYTE_LEN);
        const BYTE* P1 = reinterpret_cast<const BYTE*>(m_num);
        BYTE* P2 = _rawData.Ref();
        loop ( i, BYTE_LEN )
        {
            *P2++ = *P1++;
        }
    }
 
    const BYTE* RefRawData(void) const
    {
        return reinterpret_cast<const BYTE*>(m_num);
    }
 
    bool GetBit(INDEX bitNo) const
    {
        size_t l = bitNo / 32;
        if ( l < DWORD_LEN )
        {
            return (m_num[l] & _BIT(bitNo % 32)) != 0;
        }
        return false;
    }
 
    void SetBit(INDEX bitNo, bool v = true)
    {
        size_t l = bitNo / 32;
        if ( l < DWORD_LEN )
        {
            if ( v )
            {
                m_num[l] |= _BIT(bitNo % 32);
            }
            else
            {
                m_num[l] &= ~_BIT(bitNo % 32);
            }
        }
    }
 
    CLongIntegerT& operator=(const CLongIntegerT& other)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] = other.m_num[i];
        }
        return *this;
    }
 
    CLongIntegerT& operator=(LONGLONG val)
    {
        LONGLONG* P =reinterpret_cast<LONGLONG*>(m_num);
        *P = val;
        DWORD u = (val < 0) ? DWORD_MAX : 0;
        for ( size_t i = 2 ; i < DWORD_LEN; i++ )
        {
            m_num[i] = u;
        }
        return *this;
    }
 
    CLongIntegerT operator+(void) const
    {
        return *this;
    }
 
    CLongIntegerT operator-(void) const
    {
        CLongIntegerT x;
        loop ( i, DWORD_LEN )
        {
            x.m_num[i] = ~m_num[i];
        }
        if ( x.m_num[0] == DWORD_MAX )
        {
            //桁上がり
            x.m_num[0] = 0;
            for ( size_t i = 1; i < DWORD_LEN; i++ )
            {
                if ( x.m_num[i] == DWORD_MAX )
                {
                    x.m_num[i] = 0;
                }
                else
                {
                    x.m_num[i]++;
                    break;
                }
            }
        }
        else
        {
            x.m_num[0]++;
        }
        return x;
    }
 
    CLongIntegerT operator~(void) const
    {
        CLongIntegerT x;
        loop ( i, DWORD_LEN )
        {
            x.m_num[i] = ~m_num[i];
        }
        return x;
    }
 
    CLongIntegerT& operator+=(const CLongIntegerT& val)
    {
        return operator-=(-val);
    }
 
    CLongIntegerT& operator-=(const CLongIntegerT& val)
    {
        if ( this != &val )
        {
            loop ( i, DWORD_LEN )
            {
                bool isBorrow = true;
                if ( m_num[i] >= val.m_num[i] )
                {
                    isBorrow = false;
                }
                m_num[i] -= val.m_num[i];
                size_t j = i + 1;
                while ( isBorrow && j < DWORD_LEN )
                {
                    if ( m_num[j] >= 1 )
                    {
                        isBorrow = false;
                    }
                    m_num[j]--;
                    j++;
                }
            }
        }
        else 
        {
            Zero();
        }
        return *this;
    }
 
    CLongIntegerT& operator*=(const CLongIntegerT& val)
    {
        *this = operator*(*this, val);
        return *this;
    }
 
    CLongIntegerT& operator/=(const CLongIntegerT& val)
    {
        *this = operator/(*this, val);
        return *this;
    }
 
    CLongIntegerT& operator%=(const CLongIntegerT& val)
    {
        *this = operator%(*this, val);
        return *this;
    }
 
    CLongIntegerT& operator&=(const CLongIntegerT& val)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] &= val.m_num[i];
        }
        return *this;
    }
 
    CLongIntegerT& operator|=(const CLongIntegerT& val)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] |= val.m_num[i];
        }
        return *this;
    }
 
    CLongIntegerT& operator^=(const CLongIntegerT& val)
    {
        loop ( i, DWORD_LEN )
        {
            m_num[i] ^= val.m_num[i];
        }
        return *this;
    }
 
    CLongIntegerT& operator<<=(size_t val)
    {
        while ( val > 0 )
        {
            if ( val >= 32 )
            {
                for ( int i = DWORD_LEN - 1; i > 0; i-- )
                {
                    m_num[i] = m_num[i - 1];
                }
                val -= 32;
                m_num[0] = 0;
            }
            else 
            {
                for ( int i = DWORD_LEN - 1; i > 0; i-- )
                {
                    m_num[i] = (m_num[i] << 1) | ((m_num[i - 1] & 0x80000000) ? 1 : 0);
                }
                m_num[0] <<= 1;
                val--;
            }
        }
        return *this;
    }
 
    CLongIntegerT& operator>>=(size_t val)
    {
        while ( val > 0 )
        {
            if ( val >= 32 )
            {
                loop ( i, DWORD_LEN - 1 )
                {
                    m_num[i] = m_num[i + 1];
                }
                m_num[DWORD_LEN - 1] = 0;
                val -= 32;
            }
            else 
            {
                loop ( i, DWORD_LEN - 1 )
                {
                    m_num[i] = (m_num[i] >> 1) | ((m_num[i + 1] & 1) ? 0x80000000 : 0);
                }
                m_num[DWORD_LEN - 1] >>= 1;
                val--;
            }
        }
        return *this;
    }
 
    CLongIntegerT operator<<(size_t val) const
    {
        CLongIntegerT x = *this;
        x.operator<<=(val);
        return x;
    }
 
    CLongIntegerT operator>>(size_t val) const
    {
        CLongIntegerT x = *this;
        x.operator>>=(val);
        return x;
    }
 
    CLongIntegerT& operator--(void)
    {
        m_num[0]--;
        if ( m_num[0] == DWORD_MAX )
        {
            for ( size_t i = 1; i < DWORD_LEN; i++ )
            {
                m_num[i]--;
                if ( m_num[i] != DWORD_MAX )
                {
                    break;
                }
            }
        }
        return *this;
    }
 
    CLongIntegerT operator--(int)
    {
        CLongIntegerT x = *this;
        operator--();
        return x;
    }
 
    CLongIntegerT& operator++(void)
    {
        m_num[0]++;
        if ( m_num[0] == 0 )
        {
            for ( size_t i = 1; i < DWORD_LEN; i++ )
            {
                m_num[i]++;
                if ( m_num[i] != 0 )
                {
                    break;
                }
            }
        }
        return *this;
    }
 
    CLongIntegerT operator++(int)
    {
        CLongIntegerT x = *this;
        operator++();
        return x;
    }
 
    friend CLongIntegerT operator+(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT x = a;
        x.operator+=(b);
        return x;
    }
 
    friend CLongIntegerT operator-(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT x = a;
        x.operator-=(b);
        return x;
    }
 
    friend CLongIntegerT operator*(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CWorkMemT<DWORD> w(DWORD_LEN * 2);
        w.Fill(0);
        const BYTE* pV1 = reinterpret_cast<const BYTE*>(a.m_num);
        const BYTE* pV2 = reinterpret_cast<const BYTE*>(b.m_num);
        BYTE* pWork = reinterpret_cast<BYTE*>(w.Ref());
        loop ( i, BYTE_LEN )
        {
            if ( pV2[i] != 0 )
            {
                loop ( j, BYTE_LEN )
                {
                    if ( pV1[j] != 0 )
                    {
                        size_t ix = i + j;
                        BYTE* P = &pWork[ix];
                        DWORD kk = pV1[j] * pV2[i] + *P;
                        *P++ = static_cast<BYTE>(kk & 0xFF);
                        ix++;
                        kk /= 0x100;
                        while ( (kk != 0) && (ix < (BYTE_LEN * 2)) )
                        {
                            kk += *P;
                            *P++ = static_cast<BYTE>(kk & 0xFF);
                            ix++;
                            kk /= 0x100;
                        }
                    }
                }
            }
        }
        CLongIntegerT x;
        loop ( i, DWORD_LEN )
        {
            x.m_num[i] = w[i];
        }
        return x;
    }
 
    friend CLongIntegerT operator/(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT quotient;
        CLongIntegerT remainder;
        m_Divide(a, b, quotient, remainder);
        return quotient;
    }
 
    friend CLongIntegerT operator%(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT quotient;
        CLongIntegerT remainder;
        m_Divide(a, b, quotient, remainder);
        return remainder;
    }
 
    friend CLongIntegerT operator&(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT x = a;
        x.operator&=(b);
        return x;
    }
 
    friend CLongIntegerT operator|(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT x = a;
        x.operator|=(b);
        return x;
    }
 
    friend CLongIntegerT operator^(const CLongIntegerT& a, const CLongIntegerT& b)
    {
        CLongIntegerT x = a;
        x.operator^=(b);
        return x;
    }
 
    friend CLongIntegerT abs(const CLongIntegerT& val)
    {
        if ( val.IsMinus() )
        {
            return -val;
        }
        return val;
    }
 
    bool Divide(CLongIntegerT& _quotient, CLongIntegerT& _remainder, const CLongIntegerT& val) const
    {
        return m_Divide(*this, val, _quotient, _remainder);
    }
 
    virtual INT_PTR Compare(const CLongIntegerT<PLACE>& t) const
    {
        INT_PTR sign1 = IsMinus() ? -1 : 1;
        INT_PTR sign2 = t.IsMinus() ? -1 : 1;
        if ( sign1 == sign2 )
        {
            for ( int i = DWORD_LEN - 1; i >= 0; i-- )
            {
                if ( m_num[i] > t.m_num[i] )
                {
                    return sign1;
                }
                else if ( m_num[i] < t.m_num[i] )
                {
                    return -sign1;
                }
            }
        }
        else 
        {
            return sign1;
        }
        return 0;
    }
 
    bool IsMinus(void) const
    {
        return (m_num[DWORD_LEN - 1] & 0x80000000) != 0;
    }
 
    bool IsZero(void) const
    {
        loop ( i, DWORD_LEN )
        {
            if ( m_num[i] != 0 )
            {
                return false;
            }
        }
        return true;
    }
 
    bool CanExpressInt(void) const
    {
        return m_CanExpress(1);
    }
 
    int ToInt(void) const
    {
        return m_num[0];
    }
 
    bool CanExpressLonglong(void) const
    {
        if ( DWORD_LEN > 2 )
        {
            return m_CanExpress(2);
        }
        return true;
    }
 
    LONGLONG ToLonglong(void) const
    {
        LONGLONG r = m_num[1];
        r <<= 32;
        return r | m_num[0];
    }
    
    size_t GetValidBitsCount(void) const
    {
        loop_dn ( i, DWORD_LEN )
        {
            if ( m_num[i] != 0 )
            {
                loop_dn ( j, 32 )
                {
                    if ( (m_num[i] & _BIT(j)) != 0 )
                    {
                        return i * 32 + j + 1;
                    }
                }
            }
        }
        return 0;
    }
 
    CStr ToHexString(bool isUpperCase = true) const
    {
        CStr s;
        LPCTSTR lpszFmt = isUpperCase ? _T("%08X") :  _T("%08x");
        loop ( i, DWORD_LEN )
        {
            s += CStr::Fmt(lpszFmt, m_num[DWORD_LEN - 1 - i]);
        }
        return s;
    }
 
    CStr ToString(void) const
    {
        CLongIntegerT x = *this;
        bool isMinus = x.IsMinus();
        if ( isMinus )
        {
            x = -x;
        }
        CStr s;
        while ( x > 0 )
        {
            s = CStr::Fmt(_T("%09d"), (x % INT_VALUE_MAX).ToInt()) + s;
            x /= INT_VALUE_MAX;
        }
        s.TrimLeft('0');
        if ( s.IsEmpty() )
        {
            return _T("0");
        }
        if ( isMinus )
        {
            return _T("-") + s;
        }
        return s;
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        size_t l = DWORD_LEN;
        _sr << l << l;
        loop ( i, l )
        {
            _sr << m_num[i];
        }
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        Zero();
        size_t l1, l2;
        ds >> l1 >> l2;
        if ( l1 != l2 || l1 != DWORD_LEN )
        {
            throw CInvalidParamException();
        }
        loop ( i, l1 )
        {
            ds >> m_num[i];
        }
    }
 
    static size_t GetBitsCount(void)
    {
        return BIT_LEN;
    }
 
    static size_t GetBytesCount(void)
    {
        return BYTE_LEN;
    }
 
    static size_t GetMaxPlace(void)
    {
        return GetMax().ToString().GetLength() - 1;
    }
 
    static CLongIntegerT GetMax(void)
    {
        CLongIntegerT x;
        loop ( i, DWORD_LEN )
        {
            x.m_num[i] = DWORD_MAX;
        }
        x.m_num[DWORD_LEN - 1] = 0x7FFFFFFF;
        return x;
    }
 
    static CLongIntegerT GetMin(void)
    {
        CLongIntegerT x;
        x.m_num[0] = 1;
        x.m_num[DWORD_LEN - 1] = 0x80000000;
        return x;
    }
 
    static CLongIntegerT FromString(LPCTSTR lpsz)
    {
        CLongIntegerT x;
        x.SetString(lpsz);
        return x;
    }
 
    static CLongIntegerT FromHexString(LPCTSTR lpsz)
    {
        CLongIntegerT x;
        x.SetHexString(lpsz);
        return x;
    }
 
private:
 
    static bool m_Divide(const CLongIntegerT& a, const CLongIntegerT& b, CLongIntegerT& _quotient, CLongIntegerT& _remainder)
    {
        _quotient.Zero();
        _remainder.Zero();
        if ( a.IsZero() )
        {
            return true;
        }
        if ( b.IsZero() )
        {
            return false ;
        }
        CLongIntegerT aa = abs(a);
        CLongIntegerT bb = abs(b);
        if ( aa < bb )
        {
            _remainder = a;
            return true;
        }
        INT_PTR cnt = aa.GetValidBitsCount() - bb.GetValidBitsCount();
        ASSERT( cnt >= 0 );
        bb <<= cnt;
        for ( INT_PTR i = 0; i <= cnt; i++ )
        {
            _quotient <<= 1;
            if ( aa >= bb )
            {
                aa -= bb;
                _quotient.m_num[0] |= 1;
            }
            bb >>= 1;
        }
        if ( a.IsMinus() != b.IsMinus() )
        {
            _quotient = -_quotient;
        }
        _remainder = aa;
        if ( a.IsMinus() )
        {
            _remainder = -_remainder;
        }
        return true;
    }
    bool m_CanExpress(INDEX idx) const
    {
        DWORD n = m_num[idx];
        if ( n == 0 || n != DWORD_MAX )
        {
            for ( size_t i = idx + 1; i < DWORD_LEN; i++ )
            {
                if ( n != m_num[i] )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    #ifdef _TnbDOXYGEN  //Document作成用シンボル
    INT_PTR operator- (const TYP &t) const
    {
        return 0;
    }
    #endif // _TnbDOXYGEN
    enum
    {
        DWORD_LEN = PLACE,          
        BYTE_LEN = PLACE * 4,       
        BIT_LEN = PLACE * 32,       
        INT_VALUE_MAX = 1000000000, 
    };
    DWORD   m_num[DWORD_LEN];   
    friend class CLongIntegerTest;
};
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
template<> class CLongIntegerT<0> 
{
    CLongIntegerT(void); // PLACE に 0 は指定できません。
};
 
template<> class CLongIntegerT<1> 
{
    CLongIntegerT(void); // PLACE に 1 は指定できません。
};
 
#endif // _TnbDOXYGEN
 
 
 
typedef CLongIntegerT<8> INT256;
 
 
 
}; // TNB