Bigdecimal: Variable precision decimal arithmetic C/C++ library

Allocation & Free

#include <stdio.h>
#include "bigdecimal.h"
int main(int argc, char* argv[])
{
    VP_HANDLE a = VpAlloc("+1234567890.1234567890 123456789000000E0",100);
    VpPrintF (stdout,a); /* ===> 1234567890.1234567890 123456789 */
    VpFree(&a);
    return 0;
}

As the Bigdecimal variable is the container of digits,Bigdecimal offers two functions:

Bigdecimal functions	meaning
m = VpMaxLength(c)	m is the maximum number of digits c can store. m is slightly bigger than the value specified by VpAlloc() or VpMemAlloc() due to internal logic.
n = VpCurLength(c)	n is the number of digits currently stored in c.

VpMaxLength(c) and VpCurLength(c) return the sizes that may be slightly bigger than the actual values in it due to internal logic.
It is noted that VpMaxLength(c) >=VpCurLength(c) > 0.

Computation

int main(int argc, char* argv[])
{
    VP_HANDLE a = VpAlloc("+1234567890.1234567890 123456789000000E0",100);
    VP_HANDLE b = VpAlloc("20",10);
    VP_HANDLE c = VpMemAlloc(150);
    VpPrintE(stdout,VpMul(c,a,b)); /* c=a*b ===> 0.2469135780 2469135780 246913578E11 */
    VpFree(&a);
    VpFree(&b);
    VpFree(&c);
    return 0;
}

Bigdecimal also offers some mathematical functions(most functions return resulting 'c').

Bigdecimal functions	meaning	notes
c = VpSqrt(c,a)	c = a1/2	computed by Newton's method.
c = VpPI(c)	c = 3.141592....	computed by Matine's formula.
c = VpSin(c,a)	c = sin(a)	see Note*
c = VpCos(c,a)	c = cos(a)	see Note*
c = VpAtan(c,a)	c = tan-1(a)	|a|<=1, see Note*
c = VpExp(c,a)	c = ea	see Note*
c = VpLog(c,a)	c = logea	0<a<= 2, see Note*
c = VpPower(c,a,n)	c = an	n must be an ingteger.

* In most functions,VpMaxLength(c) digits are stored to resulting c.

Note^*:

• sin,cos,atan,exp and log are computed by series expansion,and have some experimental aspect.
• The argument for each function(a) must have small value to obtain convergence.
• The numerical operation such as: If a>3.141592....,then a = a-3.141592....,is not done internally,so this should be done before calling.
  This is also applies to log(ab)=log(a)+log(b),where a and b must be in range 0<(a,b)<=2.

#define F(H,V) printf(H);VpPrintF(stdout,V);printf("\n");
#define E(H,V) printf(H);VpPrintE(stdout,V);printf("\n");

    VP_HANDLE sqrt2 = VpMemAlloc(100);
    VP_HANDLE pi    = VpMemAlloc(100);
    VP_HANDLE pi2   = VpMemAlloc(100);
    VP_HANDLE one   = VpMemAlloc(100);
    VP_HANDLE two   = VpAlloc("2",1);
    VP_HANDLE r;
    VP_UINT   m;

    F("Sqrt(2)   =",VpSqrt(sqrt2,two));                 /* sqrt2 = sqrt(2) */
    VpFree(&two);two = VpAlloc("0",VpCurLength(sqrt2)*2+1);
    F("Sqrt(2)**2=",VpMul(two,sqrt2,sqrt2));             /* two = sqrt(2)**2  ==> 2.0 */
    F("pi        =",VpPI(pi));                           /* pi  = 3.141592...         */
    m = VpCurLength(pi)+VpCurLength(two)+1;
    if(m<VpMaxLength(pi2)) m = VpMaxLength(pi2)+1;
    r = VpAlloc("0",m);
    F("pi2       =",VpDiv(pi2,r,pi,two));                /* pi2 = pi/2 */
    E("sin(pi2)  =",VpSin(one,pi2));                     /* one = sin(pi/2)   ==> 1.0 */
    VpFree(&r);
    .........

Sqrt(2)   = 1.4142135623 7309504880 1688724209 6980785696 7187537694 8073176679 7379907324 7846210703 8850387534 3276415727
Sqrt(2)**2= 1.9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 0096588757 8795506493 0439931247 0016809150 7199370597 5256343471 3223747479 7111963099 3958184437 6132938529
pi        = 3.1415926535 8979323846 2643383279 5028841971 6939937510 5820974944 5923078164 0628620899 8628034825 3421170676
pi2       = 1.5707963267 9489661923 1321691639 7514420985 8469968755 2910487472 2961539082 0314310449 9314017412 671058
sin(pi2)  = 0.9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999999 9999999991 0017E0

Display/Print

Bigdecimal value is printed like:

E-format ==> 0.xxxxxxxxxx....Eeee
F-format ==> xxxxxxxx.yyyyyyyyyyy

Bigdecimal value can be converted to string(character array).

Bigdecimal functions	meaning
char *szE = VpToStringE(c,szE)	szE <== E-format of c.
char *szF = VpToStringF(c,szF)	szF <== F-format of c.

The array size of szE and szF must be equal to or greater than the value returned by

Bigdecimal functions	meaning
m = VpStringLengthE(c)	m is a maximum character array size to represent c in E-format.
m = VpStringLengthF(c)	m is a maximum character array size to represent c in F-format.

respectively.

DigitSeparationCount
Because the output string length of the Bigdecimal can be very long,you can insert a character(DigitSeparator) in every DigitSeparationCount in output string for readablity.
This can be zero which means the string is not separated.

  VP_UINT  VpGetDigitSeparationCount();          /* default = 10 */
  VP_UINT  VpSetDigitSeparationCount(VP_UINT m);

DigitSeparator
The character to insert to output string.
This can not be '+','-', or any digit character.
This character can also be inserted to input string at any place except for exponent part for VpAlloc(),

  char  VpGetDigitSeparator();                  /* default = ' ' */
  char  VpSetDigitSeparator(char c);

• '+' ... '+' is always put on positive number.
• ' ' ... ' ' is always put on positive number.
• '\0' ... Nothing is put on positive number.

  char  VpGetDigitLeader();                     /* default = ' ' */
  char  VpSetDigitLeader(char c);

Rounding operation

Bigdecimal functions	meaning
f = VpGetRoundMode()	f is a rounding mode listed bellow.
f = VpSetRoundMode(f)	f is a rounding mode listed bellow.

where f is the one of default rouding modes listed bellow.

Round mode	Meaning	Value
VP_ROUND_UP	round away from zero.	1
VP_ROUND_DOWN	round towards zero(truncate).	2
VP_ROUND_HALF_UP	round up if the digit >= 5 otherwise truncated(default).	3
VP_ROUND_HALF_DOWN	round up if the digit >= 6 otherwise truncated.	4
VP_ROUND_CEILING	round towards positive infinity(ceil).	5
VP_ROUND_FLOOR	round towards negative infinity(floor).	6
VP_ROUND_HALF_EVEN	round towards the even neighbor(Banker's rounding).	7

The position of round operation can explicitly specified by following 2 functions.
Both function return resulting c.

Bigdecimal functions	meaning
c = VpScaleRound(c,i)	i is the position of round operation mesured from decimal point. If i>=0,then the (i+1)th digit counted from the decimal point to right direction is processed(resulting number of digits after decimal point is less than or equal to i). If i<0,then the i-th digit counted from the decimal point to left direction is processed(at least i 0s are placed from the decimal point to left).
c = VpLengthRound(c,i)	Round operation is done at the i-th position counted from the left side of the number.

Example:

    VP_HANDLE c = VpAlloc("5555555555.5555555555",1);
    VP_HANDLE a = VpMemAlloc(VpMaxLength(c));
    VpAsgn(a,c,1); F("ScaleRound ( 0)= ",VpScaleRound (c, 0));
    VpAsgn(c,a,1); F("ScaleRound ( 2)= ",VpScaleRound (c, 2));
    VpAsgn(c,a,1); F("ScaleRound (-2)= ",VpScaleRound (c,-2));
    VpAsgn(c,a,1); F("LengthRound(12)= ",VpLengthRound(c,12));
    VpAsgn(c,a,1); F("LengthRound( 8)= ",VpLengthRound(c, 8));

ScaleRound ( 0)=  5555555556
ScaleRound ( 2)=  5555555555.56
ScaleRound (-2)=  5555555600
LengthRound(12)=  5555555555.56
LengthRound( 8)=  5555555600

  VP_EXPORT(VP_HANDLE) VpAsgn2(VP_HANDLE c, VP_HANDLE a, int isw,int mode)
  VP_EXPORT(VP_HANDLE) VpScaleRound2(VP_HANDLE a, int ixRound,int mode)
  VP_EXPORT(VP_HANDLE) VpLengthRound2(VP_HANDLE a, int ixRound,int mode)

Infinity,NaN(Not a Number),Zero

Creation

• Infinity
  Allocation:VpAlloc("Infinity",1),VpAlloc("+Infinity",1),VpAlloc("-Infinity",1)
  Computation: 1/0,-1/0 ...
• NaN
  Allocation:VpAlloc("NaN",1)
  Computation: 0/0,Infinity/Infinity,NaN*1,NaN+1 ...
• Zero
  Allocation:VpAlloc("0",1),VpAlloc("+0",1),VpAlloc("-0",1)
  Computation: 1*0,-1*0 ...

Zero has two different variations as +0.0 and -0.0. But,still, +0.0==-0.0 is true.

Error handling

To check if the returned value is valid VP_HANDLE,use VpValid() or VpInvalid() as:

   VP_HANDLE h = VpAlloc("12345+123",2); /* ==> ERROR:  + is placed at illegal position. */
   if(VpInvalid(h)) {
       printf("ERROR returned by VpAlloc()\n");
       exit(0);
   }
   ...... 

Exception handler

void MyException(VP_HANDLE h,const char *msg)
{
    printf("MyException(%s)\n",msg);
}
void main(int argc, char* argv[])
{
    VpSetExceptionHandler(MyException);
    E("Err =",VpAlloc("-0..123",1)); /* ERROR => this causes MyException() is called within VpAlloc() */
}

MyException(Bad numeric string for VpAlloc())
VpPrintF():Invalid handle(1)

miscellaneous

Bigdecimal structure

/*
 * VP representation
 *  r = 0.xxxxxxxxx *BASE**exponent
 */
typedef struct {
    VP_UINT   Size;    /* all byte size of this structure(used in realloc() case).  */
    VP_UINT   MaxPrec; /* Maximum precision size                          */
                       /* This is the actual size of frac[]               */
                       /*(frac[0] to frac[MaxPrec-1] are available).      */
    VP_UINT   Prec;    /* Current precision size.                         */
                       /* This indicates how much the.                    */
                       /* the array frac[] is actually used.              */
    VP_UINT   Tag;     /* Space for the user(Bigdecimal never touch this) */
                       /* Use VpSetTag() or VpGetTab() to access.         */
    int       exponent;/* Exponent part.                                  */
    int       sign;    /* Attributes of the value.                        */
                       /* See VP_SIGN_xxxxxxx defined.
                        *        ==0 : NaN
                        *          1 : Positive zero
                        *         -1 : Negative zero
                        *          2 : Positive number
                        *         -2 : Negative number
                        *          3 : Positive infinite number
                        *         -3 : Negative infinite number
                        */
    VP_DIGIT   frac[1]; /* Array of fraction part. */
} Real;

#define VP_SIGN_NaN                0 /* NaN                      */
#define VP_SIGN_POSITIVE_ZERO      1 /* Positive zero            */
#define VP_SIGN_NEGATIVE_ZERO     -1 /* Negative zero            */
#define VP_SIGN_POSITIVE_FINITE    2 /* Positive finite number   */
#define VP_SIGN_NEGATIVE_FINITE   -2 /* Negative finite number   */
#define VP_SIGN_POSITIVE_INFINITE  3 /* Positive infinite number */
#define VP_SIGN_NEGATIVE_INFINITE -3 /* Negative infinite number */