vgl::arith::numberSystem 1.3

最近群里有人聊N! (N<=100) 于是发现这种代码的复用还是有点意义的，于是把自己曾经写的一个numberSystem子库公布下。


它能够实现任意精度的带小数位在任意进制下的任意加减乘除余等等。

自从写BinaryTree泛化类采用down-up原语设计后，我就一直喜欢在写内聚性很强的东西时，从元操作（原语）开始实现，之后其他所有之上的操作都能通过几个原语的组合实现。所以能够避免混乱的代码结构和浪费大量调试时间。

/**/ /*numberSystem.cpp :vgl::numberSystem*/
/**/ /*----------------------------------------------------------------------------
Simple v1.2
Developer: Zblc
vgl::numberSystem

classes:
    numberSystem                            ：大数类
                                        

macros:
    BigReal(STR)                            ：临时测试用大数对象

global variable:
    numberSystem VGL_G_TEMP;                ：临时传递用对象
    char VGL_G_TEMP_STR[MAX_DIGIT];         ：临时传递用字符串

include:
    base.h                                  ：VGL基库
    string.h                                ：VGL泛型字符串库 
--------------------------- --------------------------------------------------*/




#ifndef NUMBERSYSTEM__
#define  NUMBERSYSTEM__


#include  " base.h "
#include  " string.h "
#define  MAX_DIGIT 500


#define  BigReal(STR)  (*(numberSystem*)( new numberSystem(STR)) )



class  numberSystem
{

private:
    int radix;
    int num[MAX_DIGIT];
    int len;
    char sign;
    int decNum;//decreasing Digit till dot
    void init(int Radix=10);
    void init(int *Num,int Len=0,int Radix=10,int DecNum=-1);
    void init(char *Num,int Len=0,int Radix=10);
    void addFrontZero(numberSystem& obj,int Num);
    void addBackZero(numberSystem& obj,int Num);
    void delFrontZero(numberSystem & obj);
    void delBackZero(numberSystem& obj);
    void balanceNumber(numberSystem& First,numberSystem& Second);
    void cleanNumber(numberSystem& Obj);
    
    void addStrict(numberSystem & Right,numberSystem & Result);
    void subtractStrict(numberSystem & Right,numberSystem & Result);
    void mulStrict(int Factor,numberSystem & Result);
    int getMaxFactor(numberSystem& Obj,numberSystem& Multi);
    int smallerThanAsInt(numberSystem& Copy);
    
public:
    numberSystem();
    numberSystem(int Radix);
    numberSystem(int *Num,int Len=0,char Sign='+',int DecNum=-1,int Radix=10);
    numberSystem(char *Num,int Len=0,char Sign='+',int Radix=10);
    void add(numberSystem & Right,numberSystem & Result);
    void sub(numberSystem & Right,numberSystem & Result);
    void mul(numberSystem & Right,numberSystem & Result);
    void div(numberSystem & Right,numberSystem & Result);
    void mod(numberSystem & Right,numberSystem & Result);

    
    char getSign();
    int getLen();
    int* getNum();
    char* toChars();
    adt::string toString();
    numberSystem getInteger();
    numberSystem getDecimal();
    
    
    int* operator ()();
    int& operator[](int i);
    int operator > (numberSystem& Copy);
    int operator >= (numberSystem& Copy);
    int operator <= (numberSystem& Copy);
    int operator < (numberSystem& Copy);
    int operator == (numberSystem& Copy);
    int operator == (char* strNum);
    numberSystem operator +(numberSystem& Right);
    numberSystem operator +=(numberSystem& Right);

    numberSystem operator -(numberSystem& Right);
    numberSystem operator -=(numberSystem& Right);

    numberSystem operator *(numberSystem& Right);
    numberSystem operator *=(numberSystem& Right);

    numberSystem operator /(numberSystem& Right);
    numberSystem operator /=(numberSystem& Right);

    numberSystem operator %(numberSystem& Right);
    numberSystem operator %=(numberSystem& Right);

    numberSystem& operator=(const numberSystem& Copy);

    
} ;


#endif

#include  " numberSystem.h "

numberSystem VGL_G_TEMP;
char  VGL_G_TEMP_STR[MAX_DIGIT];
numberSystem numberSystem:: operator   + (numberSystem &  Right)
{
    add(Right,VGL_G_TEMP);
    return VGL_G_TEMP;
}
numberSystem numberSystem:: operator   += (numberSystem &  Right)
{
    add(Right,*this);
    return *this;
}
numberSystem numberSystem:: operator   - (numberSystem &  Right)
{
    sub(Right,VGL_G_TEMP);
    return VGL_G_TEMP;
}
numberSystem numberSystem:: operator   -= (numberSystem &  Right)
{
    sub(Right,*this);
    return *this;
}
numberSystem numberSystem:: operator   * (numberSystem &  Right)
{
    mul(Right,VGL_G_TEMP);
    return VGL_G_TEMP;
}
numberSystem numberSystem:: operator   *= (numberSystem &  Right)
{
    mul(Right,*this);
    return *this;
}
numberSystem numberSystem:: operator   / (numberSystem &  Right)
{
    div(Right,VGL_G_TEMP);
    return VGL_G_TEMP;
}
numberSystem numberSystem:: operator   /= (numberSystem &  Right)
{
    div(Right,*this);
    return *this;
}
numberSystem numberSystem:: operator   % (numberSystem  &  Right)
{
    mod(Right,VGL_G_TEMP);
    return VGL_G_TEMP;
}
numberSystem numberSystem:: operator   %= (numberSystem  &  Right)
{
    mod(Right,*this);
    return *this;
}
void  numberSystem::init( int  Radix /**/ /*=10*/ )
{
    decNum=-1;
    radix=Radix;
}
void  numberSystem::init( int   * Num, int  Len /**/ /*=0*/ , int  Radix /**/ /*=10*/ , int  DecNum /**/ /*=-1*/ )
{
    decNum=DecNum;
    radix=Radix ;
    if(!Len)
        for(;Num[Len]<=-1;Len++);
    else if(Len<0)
        TEST_THROW("numberSystem::init(..)")
        len=Len;
    for(;Len!=0;Len--)
        num[Len-1]=Num[Len-1];
}
void  numberSystem::init( char   * Num, int  Len /**/ /*=0*/ , int  Radix /**/ /*=10*/ )
{
    decNum=-1;
    radix=Radix ;
    if(!Len)
        for(;Num[Len]!='\0';Len++);
    else if(Len<0)
        TEST_THROW("numberSystem::init(..)")
        len=Len;

    int k=0,j=0,tag=0;
    if(Num[0]=='+')
        sign='+',Num++,tag=1,len--;
    else if(Num[0]=='-')
        sign='-',Num++,tag=1,len--;

    Len-=tag;
    for(;j!=Len;j++)
        if(Num[j]!='.')
        {
            num[k]=Num[j]-48;
            k++;
        }else
        {
            decNum=j;
            len--;
        }
    if(decNum==-1)
        decNum=len;

}
void  numberSystem::addFrontZero(numberSystem &  obj, int  Num)
{
    for(int i=obj.len+Num-1;i!=Num-1;i--)
        obj.num[i]=obj.num[i-Num];

    for(int i=0;i!=Num;i++)
        obj.num[i]=0;

    obj.decNum+=Num;
    obj.len+=Num;
}
void  numberSystem::addBackZero(numberSystem &  obj, int  Num)
{
    for(int i=0;i!=Num;i++)
        obj.num[i+obj.len]=0;
    obj.len+=Num;

}
void  numberSystem::delFrontZero(numberSystem  &  obj)
{
    if(obj.len==1||(obj.decNum==1))
        return;

    int k=0;
    for(;(k!=obj.len)&&(obj.num[k]==0)&&(k!=obj.decNum);k++);


    if(k==obj.decNum)
        k--;
    for(int i=0;i!=obj.len-k;i++)
        obj.num[i]=obj.num[i+k];

    if(k==obj.len)
    {

        obj.num[0]=0;
        --k;
    }

    obj.len-=k;
    if(obj.decNum>0)
        obj.decNum-=k;

}
void  numberSystem::delBackZero(numberSystem &  obj)
{
    int i=obj.len-1;
    for(;;i--)
    {
        if(obj.num[i]==0&&i>obj.decNum-1)
            obj.len--;
        else
            return;
    }
}
void  numberSystem::balanceNumber(numberSystem &  First,numberSystem &  Second)
{
    if(First.decNum>Second.decNum)
    {
        addFrontZero(Second,First.decNum-Second.decNum);
    }
    else if(First.decNum<Second.decNum)
    {
        addFrontZero(First,Second.decNum-First.decNum);
    }


    if(First.len-First.decNum>Second.len-Second.decNum)
    {
        addBackZero(Second,(First.len-First.decNum)-(Second.len-Second.decNum));
    }
    else if(First.len-First.decNum<Second.len-Second.decNum)
    {

        addBackZero(First,(Second.len-Second.decNum)-(First.len-First.decNum));
    }
}
void  numberSystem::cleanNumber(numberSystem &  Obj)
{
    delFrontZero(Obj);
    delBackZero(Obj);
}

void  numberSystem::addStrict(numberSystem  &  Right,numberSystem  &  Result)
{
    if(radix!=Right.radix)
        TEST_THROW("numberSystem:operands differed in radix");

    numberSystem First=*this,Second=Right;
    int i,carry=0;

    balanceNumber(First,Second);

    i=First.len;
    Result.init(radix);
    Result.decNum=First.decNum+1;
    Result.len=i+1;

    for(;i!=0;i--)
    {
        Result.num[i]=(carry+First[i-1]+Second[i-1])%radix;
        carry=(carry+First[i-1]+Second[i-1])/radix;
    }

    Result[i]=carry;
    cleanNumber(Result);

}
void  numberSystem::subtractStrict(numberSystem  &  Right,numberSystem  &  Result)
{
    if(radix!=Right.radix)
        TEST_THROW("numberSystem:operands differed in radix");

    numberSystem First=*this,Second=Right;

    int i,carry=0;

    balanceNumber(First,Second);

    if(First.smallerThanAsInt(Second))
    {
        atom::swap(First,Second);
        Result.sign='-';
    }else
    {
        Result.sign='+';
    }

    i=First.len-1;
    Result.init(radix);
    Result.decNum=First.decNum;
    Result.len=i+1;

    for(;i!=-1;i--)
        if(First[i]+carry>=Second[i])
        {
            Result.num[i]=First[i]-Second[i]+carry;
            carry=0;
        }else
        {
            Result.num[i]=radix-Second[i]+First[i]+carry;
            carry=-1;
        }
    cleanNumber(Result);

}
void  numberSystem::mulStrict( int  Factor,numberSystem  &  Result)
{
    Result.init(radix);
    int carry=0,i=len-1,j=len;
    for(;i!=-1;i--,j--)
    {
        Result.num[j]=(num[i]*Factor+carry)%radix;

        carry=(num[i]*Factor+carry)/radix;
    }
    Result.num[j]=carry;
    Result.len=len+1;
    Result.decNum=Result.len;
    delFrontZero(Result);    
}


int  numberSystem::getMaxFactor(numberSystem &  Obj,numberSystem &  Multi)
/**/ /* Obj>=Multi*MAX(Result) */
{
    if(Obj.radix!=Multi.radix)
        TEST_THROW("numberSystem: in getMaxFactor radixes differ ");
    numberSystem _temp(Obj.radix);
    for(int i=9;i!=-1;i--)
    {
        Multi.mulStrict(i,_temp);

        if(!Obj.smallerThanAsInt(_temp))
        {
            return i;
        }
    }
    return 0;
}

numberSystem::numberSystem():radix( 10 ),len( 0 ),sign( ' + ' )
{
}
numberSystem::numberSystem( int  Radix):radix(Radix),len( 0 ),sign( ' + ' )
{
}
numberSystem::numberSystem( int   * Num, int  Len /**/ /*=0*/ , char  Sign /**/ /*='+'*/ , int  DecNum /**/ /*=-1*/ , int  Radix /**/ /*=10*/ )
:radix(Radix),sign(Sign)
{
    init(Num,Len,Radix,DecNum);
}
numberSystem::numberSystem( char   * Num, int  Len /**/ /*=0*/ , char  Sign /**/ /*='+'*/ , int  Radix /**/ /*=10*/ )
:radix(Radix),sign(Sign)
{
    init(Num,Len,Radix);
}
void  numberSystem::add(numberSystem  &  Right,numberSystem  &  Result)
{
    if(sign=='+')
    {
        if(Right.sign=='+')
        {
            addStrict(Right,Result);

        }else
        {
            subtractStrict(Right,Result);
        }
    }else if(sign=='-')
    {
        if(Right.sign=='+')
        {
            Right.subtractStrict(*this,Result);

        }else
        {
            addStrict(Right,Result);
            Result.sign='-';
        }
    }

}
void  numberSystem::sub(numberSystem  &  Right,numberSystem  &  Result)
{
    if(sign=='+')
    {
        if(Right.sign=='+')
        {
            subtractStrict(Right,Result);
        }else
        {
            addStrict(Right,Result);
        }
    }else if(sign=='-')
    {
        if(Right.sign=='+')
        {
            addStrict(Right,Result);
            Result.sign='-';
        }else
        {
            Right.subtractStrict(*this,Result);
        }
    }

}
void  numberSystem::mul(numberSystem  &  Right,numberSystem  &  Result)
{
    numberSystem First=*this,Second=Right;
    Result.init("0");
    numberSystem _temp("0"),_temp2("0");
    int Decimal=First.len+Second.len-First.decNum-Second.decNum;


    int dig=0;
    for(int i=Second.len-1;i!=-1;i--,dig++){
        First.mulStrict(Second.num[i],_temp);

        for(int j=0;j!=dig;j++)
        {
            _temp.num[_temp.len++]=0;
            _temp.decNum++;
        }
        _temp.add(_temp2,_temp2);

    }
    Result=_temp2;
    Result.decNum=Result.len-Decimal;
    cleanNumber(Result);
    if(sign==Right.sign)
    {
        Result.sign='+';
    }else
    {
        Result.sign='-';
    }

}
void  numberSystem::div(numberSystem  &  Right,numberSystem  &  Result)
{
    if(sign==Right.sign) Result.sign='+';
    else Result.sign='-';
    if(Right=="0")
        TEST_THROW("numberSystem: in div divisor is zero ");
    if((*this)=="0"){
        Result=(*this);
        return ;
    }
    numberSystem First=*this,Second=Right,_temp(radix),_temp2("10");
    int i=0,j=0,k=max(len-decNum,Right.len-Right.decNum);
    Result.init("");

    for(int t=0;t!=k;t++){
        First.mul(_temp2,First);
        Second.mul(_temp2,Second);
    }
    for(;Result.len!=MAX_DIGIT;){
        for(int s=0;_temp.smallerThanAsInt(Second);s++){
            _temp.num[_temp.len++]=First.num[i++];
            if(s>0){
                Result.num[Result.len++]=0;
                if(i-1<=First.len)
                    Result.decNum++;
            }            
            if(i>=First.len) First.num[i]=0;
            _temp.decNum=_temp.len;
            cleanNumber(_temp);
            if(_temp=="0") break;
        }
        i<=First.len?Result.decNum++:1;
        Result.num[Result.len++]=getMaxFactor(_temp,Second);
        Second.mulStrict(Result.num[Result.len-1],_temp2);
        _temp.sub(_temp2,_temp);
        if((_temp=="0")&&(i>=First.len))
            break;
    }
    cleanNumber(Result);

}

int *  numberSystem:: operator  ()()
{
    return num;
}
int *  numberSystem::getNum()
{
    return num;
}
int &  numberSystem:: operator []( int  i)
{
    return num[i];
}

int  numberSystem::getLen()
{
    return len;
}
char  numberSystem::getSign()
{
    return sign;
}
numberSystem &  numberSystem:: operator = ( const  numberSystem &  Copy)
{
    sign=Copy.sign;
    len=Copy.len;
    radix=Copy.radix;
    decNum=Copy.decNum;

    for(int i=0;i!=Copy.len;i++)
        num[i]=Copy.num[i];

    return *this;
}
int  numberSystem:: operator   >  (numberSystem &  Copy)
{
    if(radix!=Copy.radix)
        TEST_THROW("numberSystem: in operator <  radixes differ ");

    if(*this==Copy)
        return 0;
    return (*this-Copy).sign=='+'?1:0;
}
int  numberSystem:: operator   >=  (numberSystem &  Copy)
{
    return !(*this<Copy);
}
int  numberSystem:: operator   <=  (numberSystem &  Copy)
{
    return !(*this>Copy);
}
int  numberSystem:: operator   <  (numberSystem &  Copy)
{
    if(radix!=Copy.radix)
        TEST_THROW("numberSystem: in operator <  radixes differ ");

    if(*this==Copy)
        return 0;
    return (*this-Copy).sign=='+'?0:1;
}
int  numberSystem::smallerThanAsInt(numberSystem &  Copy)
{
    if(len<Copy.len)
        return 1;
    else if(len>Copy.len)
        return 0;

    for(int i=0;i!=len;i++)
        if(num[i]<Copy.num[i])
            return 1;
        else if(num[i]>Copy.num[i])
            return 0;

    return 0;
}
int  numberSystem:: operator   ==  (numberSystem &  Copy)
{
    if(radix!=Copy.radix)
        TEST_THROW("numberSystem: in operator ==  radixes differ ");

    if(len!=Copy.len)
        return 0;

    if(sign!=Copy.sign)
        return 0;

    for(int i=0;i!=len;i++)
        if(num[i]!=Copy.num[i])    
            return 0;

    return 1;
}
int  numberSystem:: operator   ==  ( char *  strNum)
{
    VGL_G_TEMP.init(strNum);
    return VGL_G_TEMP==*this;
}

char *  numberSystem::toChars()
{
    adt::string _temp=toString();
    for(int i=0;i!=_temp.len;i++)
        VGL_G_TEMP_STR[i]=_temp[i];
    return VGL_G_TEMP_STR;

}
adt:: string  numberSystem::toString()
{
    adt::string _temp;
    if(sign=='-')
        _temp<<'-';
    for(int i=0;i!=len;i++)
        if(decNum!=i)
            _temp<<(char)(num[i]+48);
        else
            _temp<<'.'<<(char)(num[i]+48);
    _temp<<(char)0;
    return _temp;
}


numberSystem numberSystem::getInteger()
{
    VGL_G_TEMP=*this;
    VGL_G_TEMP.len=VGL_G_TEMP.decNum;
    VGL_G_TEMP.sign='+';
    return VGL_G_TEMP;
}
numberSystem numberSystem::getDecimal()
{
    return *this-getInteger();
}

void  numberSystem::mod(numberSystem  &  Right,numberSystem  &  Result)
{
    if(this->len!=this->decNum||Right.len!=Right.decNum)
        TEST_THROW("numberSystem: in function mod  ,the legal number appears");
    numberSystem First=*this,Second=Right;
    First.sign='+';
    Second.sign='+';
    Result=First-(((First)/Second).getInteger())*Second;
    Result.sign=(this->sign==Right.sign)?'+':'-';
}

关于case 就不发了,想执行的可以留言，因为还涉及到公共基础子库的引入.