10 #ifdef BIGDECIMAL_DEBUG 11 # define BIGDECIMAL_ENABLE_VPRINT 1 16 #ifndef BIGDECIMAL_DEBUG 35 #define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \ 37 (a) == -1 ? (b) < -(max) : \ 39 ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \ 40 ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b))) 41 #define SIGNED_VALUE_MAX INTPTR_MAX 42 #define SIGNED_VALUE_MIN INTPTR_MIN 43 #define MUL_OVERFLOW_SIGNED_VALUE_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, SIGNED_VALUE_MIN, SIGNED_VALUE_MAX) 68 #define ENTER(n) volatile VALUE RB_UNUSED_VAR(vStack[n]);int iStack=0 69 #define PUSH(x) (vStack[iStack++] = (VALUE)(x)) 70 #define SAVE(p) PUSH((p)->obj) 71 #define GUARD_OBJ(p,y) ((p)=(y), SAVE(p)) 73 #define BASE_FIG RMPD_COMPONENT_FIGURES 74 #define BASE RMPD_BASE 76 #define HALF_BASE (BASE/2) 77 #define BASE1 (BASE/10) 80 #define DBLE_FIG (DBL_DIG+1) 83 #ifndef RRATIONAL_ZERO_P 84 # define RRATIONAL_ZERO_P(x) (FIXNUM_P(rb_rational_num(x)) && \ 85 FIX2LONG(rb_rational_num(x)) == 0) 88 #ifndef RRATIONAL_NEGATIVE_P 89 # define RRATIONAL_NEGATIVE_P(x) RTEST(rb_funcall((x), '<', 1, INT2FIX(0))) 92 #ifndef DECIMAL_SIZE_OF_BITS 93 #define DECIMAL_SIZE_OF_BITS(n) (((n) * 3010 + 9998) / 9999) 98 # define RB_OBJ_CLASSNAME(obj) rb_obj_class(obj) 99 # define RB_OBJ_STRING(obj) (obj) 101 # define PRIsVALUE "s" 102 # define RB_OBJ_CLASSNAME(obj) rb_obj_classname(obj) 103 # define RB_OBJ_STRING(obj) StringValueCStr(obj) 106 #ifndef HAVE_RB_RATIONAL_NUM 110 #ifdef HAVE_TYPE_STRUCT_RRATIONAL 118 #ifndef HAVE_RB_RATIONAL_DEN 122 #ifdef HAVE_TYPE_STRUCT_RRATIONAL 130 #define BIGDECIMAL_POSITIVE_P(bd) ((bd)->sign > 0) 131 #define BIGDECIMAL_NEGATIVE_P(bd) ((bd)->sign < 0) 136 #define DoSomeOne(x,y,f) rb_num_coerce_bin(x,y,f) 161 #ifdef BIGDECIMAL_ENABLE_VPRINT 162 static int VPrint(
FILE *fp,
const char *cntl_chr,
Real *a);
178 const Real *pv = ptr;
185 #ifdef RUBY_TYPED_FREE_IMMEDIATELY 243 if (prec < 0)
goto unable_to_coerce_without_prec;
244 if (prec >
DBL_DIG+1)
goto SomeOneMayDoIt;
261 if (prec < 0)
goto unable_to_coerce_without_prec;
263 if (orig ==
Qundef ? (orig = v, 1) : orig != v) {
266 if (pv ==
NULL)
goto SomeOneMayDoIt;
289 #ifdef ENABLE_NUMERIC_STRING 310 unable_to_coerce_without_prec:
313 "%"PRIsVALUE" can't be coerced into BigDecimal without a precision",
434 while((*pch) != (
unsigned char)
'\0' && (ch = *pch++) != (
unsigned char)
':') {
438 m = m*10 + (
unsigned long)(ch-
'0');
449 static unsigned short 469 if (
NIL_P(str_mode))
goto invalid;
498 static unsigned short 579 f = (
unsigned long)
NUM2INT(which);
591 (fo & (~VP_EXCEPTION_INFINITY))));
596 (fo & (~VP_EXCEPTION_NaN))));
601 (fo & (~VP_EXCEPTION_UNDERFLOW))));
606 (fo & (~VP_EXCEPTION_ZERODIVIDE))));
632 if (mx < b->Prec) mx = b->
Prec;
672 #define VpAllocReal(prec) (Real *)VpMemAlloc(offsetof(Real, frac) + (prec) * sizeof(BDIGIT)) 673 #define VpReallocReal(ptr, prec) (Real *)VpMemRealloc((ptr), offsetof(Real, frac) + (prec) * sizeof(BDIGIT)) 800 if (
VpVtoD(&d, &e, p) != 1)
812 if (
errno == ERANGE) {
813 if (d == 0.0)
goto underflow;
814 if (fabs(d) >= HUGE_VAL)
goto overflow;
840 ssize_t sign, power, denomi_power;
841 VALUE a, digits, numerator;
856 if (denomi_power < 0) {
964 if (mx == (
size_t)-1
L) {
1022 if (mx == (
size_t)-1
L) {
1104 if (e == 0)
return Qtrue;
1108 if (e >= 0)
return Qtrue;
1112 if (e > 0)
return Qtrue;
1116 if (e <= 0)
return Qtrue;
1120 if (e < 0)
return Qtrue;
1127 rb_bug(
"Undefined operation in BigDecimalCmp()");
1347 if (!
NIL_P(r))
return r;
1595 mx = av->
Prec + bv->Prec + 2;
1596 if (mx <= cv->MaxPrec) mx = cv->MaxPrec + 1;
1723 if (mx <= n) mx = n;
1779 switch (
rb_scan_args(argc, argv,
"02", &vLoc, &vRound)) {
1916 #ifdef BIGDECIMAL_DEBUG 1917 VPrint(stderr,
"floor: c=%\n", c);
2024 else if (*psz ==
'+') {
2028 while ((ch = *psz++) != 0) {
2033 if (ch ==
'F' || ch ==
'f') {
2038 mc = mc*10 + ch -
'0';
2052 nc += (nc + mc - 1) / mc + 1;
2106 if(psz1[0] ==
'-') {
2113 if (psz1[0] ==
'N') s = 0;
2166 #define BigMath_exp(x, n) BigMath_s_exp(rb_mBigMath, (x), (n)) 2167 #define BigMath_log(x, n) BigMath_s_log(rb_mBigMath, (x), (n)) 2190 #define is_positive(x) (!is_negative(x)) 2264 VALUE log_x, multiplied, y;
2313 switch (
TYPE(vexp)) {
2322 if (d ==
round(d)) {
2362 "wrong argument type %"PRIsVALUE" (expected scalar Numeric)",
2443 "a non-integral exponent for a negative base");
2501 if (ma < 0) ma = -ma;
2502 if (ma == 0) ma = 1;
2600 if (
self != other) {
2614 if (
rb_scan_args(argc, argv,
"11", &iniValue, &nFig) == 1) {
2621 switch (
TYPE(iniValue)) {
2647 "can't omit precision for a %"PRIsVALUE".",
2673 return pv->
obj = obj;
2696 if (
NIL_P(nFig))
return nCur;
2854 infinite =
isinf(flo);
2856 if (!infinite && !nan) {
2887 else if (vx ==
NULL) {
2906 ssize_t m = n -
vabs(ey - ed);
2995 if (zero || negative)
break;
3003 infinite =
isinf(flo);
3005 if (!zero && !negative && !infinite && !nan) {
3013 if (zero || negative)
break;
3019 "Complex argument for BigMath.log");
3024 if (infinite && !negative) {
3038 else if (zero || negative) {
3040 "Zero or negative argument for log");
3042 else if (vx ==
NULL) {
3053 if (expo < 0 || expo >= 3) {
3070 ssize_t m = n -
vabs(ey - ed);
3086 VALUE log10, vexpo, dy;
3436 #ifdef BIGDECIMAL_DEBUG 3437 static int gfDebug = 1;
3439 static int gfCheckVal = 1;
3449 #define MemCmp(x,y,z) memcmp(x,y,z) 3450 #define StrCmp(x,y) strcmp(x,y) 3465 static void VpFormatSt(
char *psz,
size_t fFmt);
3468 #ifdef BIGDECIMAL_DEBUG 3469 static int gnAlloc = 0;
3480 #ifdef BIGDECIMAL_DEBUG 3501 #ifdef BIGDECIMAL_DEBUG 3504 printf(
" *************** All memories allocated freed ****************\n");
3508 printf(
" ??????????? Too many memory free calls(%d) ?????????????\n", gnAlloc);
3519 #define rmpd_set_thread_local_exception_mode(mode) \ 3520 rb_thread_local_aset( \ 3521 rb_thread_current(), \ 3522 id_BigDecimal_exception_mode, \ 3523 INT2FIX((int)(mode)) \ 3526 static unsigned short 3552 #define rmpd_set_thread_local_precision_limit(limit) \ 3553 rb_thread_local_aset( \ 3554 rb_thread_current(), \ 3555 id_BigDecimal_precision_limit, \ 3558 #define RMPD_PRECISION_LIMIT_DEFAULT ((size_t)0) 3569 if (
NIL_P(vlimit)) {
3589 #define rmpd_set_thread_local_rounding_mode(mode) \ 3590 rb_thread_local_aset( \ 3591 rb_thread_current(), \ 3592 id_BigDecimal_rounding_mode, \ 3593 INT2FIX((int)(mode)) \ 3680 static double fNaN = 0.0;
3681 if (fNaN == 0.0) fNaN =
Zero()/
Zero();
3688 static double fInf = 0.0;
3689 if (fInf == 0.0) fInf =
One()/
Zero();
3696 static double fInf = 0.0;
3697 if (fInf == 0.0) fInf = -(
One()/
Zero());
3704 static double nzero = 1000.0;
3711 VpIsNegDoubleZero(
double v)
3714 return MemCmp(&v,&z,
sizeof(v))==0;
3725 if (always || (exception_mode & f)) {
3862 if ((
size_t)ex > vp->
Prec) {
3899 VpConstOne =
VpAlloc(1UL,
"1");
3902 #ifdef BIGDECIMAL_DEBUG 3906 #ifdef BIGDECIMAL_DEBUG 3908 printf(
"VpInit: BaseVal = %"PRIuBDIGIT"\n", BaseVal);
3912 printf(
"\tBASE_FIG = %u\n",
BASE_FIG);
3913 printf(
"\tDBLE_FIG = %d\n",
DBLE_FIG);
3940 if (eb - mb > 0)
goto overflow;
3949 if (mb - eb > 0)
goto underflow;
3980 const char *orig_szVal = szVal;
3981 size_t i, ni, ipn, ipf, nf, ipe,
ne, dot_seen, exp_seen, nalloc;
3992 while (
ISSPACE(*szVal)) szVal++;
3993 if (*szVal !=
'#') {
4022 while ((psz[i] = szVal[ipn]) != 0) {
4028 if (psz[i] ==
'_') {
4063 if (szVal[i] ==
'-') { sign=-1; ++i; }
4064 else if (szVal[i] ==
'+') ++i;
4067 while ((v = szVal[i]) != 0) {
4080 if (szVal[i] ==
'.') {
4084 while ((v = szVal[i]) != 0) {
4101 if ((v ==
'-') || (v ==
'+')) ++i;
4102 while ((v=szVal[i]) != 0) {
4112 if (((ni == 0 || dot_seen) && nf == 0) || (exp_seen && ne == 0)) {
4119 if (mx == 0) mx = 1;
4120 nalloc =
Max(nalloc, mx);
4126 VpCtoV(vp, &szVal[ipn], ni, &szVal[ipf], nf, &szVal[ipe], ne);
4191 Real *a_ptr, *b_ptr;
4192 size_t n, na, nb, i;
4195 #ifdef BIGDECIMAL_DEBUG 4197 VPrint(stdout,
"VpAddSub(enter) a=% \n", a);
4198 VPrint(stdout,
" b=% \n", b);
4199 printf(
" operation=%d\n", operation);
4230 if (operation < 0) sw = -1;
4248 for (i=0; i < n; ++i) {
4254 else if (a->
frac[i] < b->
frac[i]) {
4305 #ifdef BIGDECIMAL_DEBUG 4307 VPrint(stdout,
"VpAddSub(result) c=% \n", c);
4308 VPrint(stdout,
" a=% \n", a);
4309 VPrint(stdout,
" b=% \n", b);
4310 printf(
" operation=%d\n", operation);
4329 size_t b_pos, b_pos_with_word_shift;
4331 BDIGIT av, bv, carry, mrv;
4333 #ifdef BIGDECIMAL_DEBUG 4335 VPrint(stdout,
"VpAddAbs called: a = %\n", a);
4336 VPrint(stdout,
" b = %\n", b);
4340 word_shift =
VpSetPTR(a, b, c, &ap, &bp, &cp, &av, &bv);
4345 if (word_shift == (
size_t)-1
L)
return 0;
4346 if (b_pos == (
size_t)-1
L)
goto Assign_a;
4353 while (b_pos > 0 && b_pos + word_shift > a_pos) {
4354 c->
frac[--c_pos] = b->
frac[--b_pos];
4357 if (b_pos == 0 && word_shift > a_pos) {
4358 while (word_shift-- > a_pos) {
4359 c->
frac[--c_pos] = 0;
4365 b_pos_with_word_shift = b_pos + word_shift;
4366 while (a_pos > b_pos_with_word_shift) {
4367 c->
frac[--c_pos] = a->
frac[--a_pos];
4374 c->
frac[--c_pos] = a->
frac[--a_pos] + b->
frac[--b_pos] + carry;
4387 c->
frac[--c_pos] = a->
frac[--a_pos] + carry;
4396 if (c_pos) c->
frac[c_pos - 1] += carry;
4405 #ifdef BIGDECIMAL_DEBUG 4407 VPrint(stdout,
"VpAddAbs exit: c=% \n", c);
4424 size_t b_pos, b_pos_with_word_shift;
4426 BDIGIT av, bv, borrow, mrv;
4428 #ifdef BIGDECIMAL_DEBUG 4430 VPrint(stdout,
"VpSubAbs called: a = %\n", a);
4431 VPrint(stdout,
" b = %\n", b);
4435 word_shift =
VpSetPTR(a, b, c, &ap, &bp, &cp, &av, &bv);
4439 if (word_shift == (
size_t)-1
L)
return 0;
4440 if (b_pos == (
size_t)-1
L)
goto Assign_a;
4454 if (b_pos + word_shift > a_pos) {
4455 while (b_pos > 0 && b_pos + word_shift > a_pos) {
4460 while (word_shift > a_pos) {
4470 b_pos_with_word_shift = b_pos + word_shift;
4471 while (a_pos > b_pos_with_word_shift) {
4472 c->
frac[--c_pos] = a->
frac[--a_pos];
4479 if (a->
frac[--a_pos] < b->
frac[--b_pos] + borrow) {
4484 c->
frac[c_pos] = a->
frac[a_pos] - b->
frac[b_pos] - borrow;
4493 if (a->
frac[--a_pos] < borrow) {
4498 c->
frac[c_pos] = a->
frac[a_pos] - borrow;
4502 if (c_pos) c->
frac[c_pos - 1] -= borrow;
4510 #ifdef BIGDECIMAL_DEBUG 4512 VPrint(stdout,
"VpSubAbs exit: c=% \n", c);
4535 size_t left_word, right_word, word_shift;
4545 left_word = b->
Prec + word_shift;
4546 right_word =
Max(a->
Prec, left_word);
4552 if (right_word > left_word) {
4562 *c_pos = right_word = left_word + 1;
4571 if (*a_pos <= round_limit) {
4572 *av = a->
frac[*a_pos];
4590 if (c->
MaxPrec >= word_shift + 1) {
4591 *b_pos = c->
MaxPrec - word_shift - 1;
4592 if (*b_pos + word_shift <= round_limit) {
4593 *bv = b->
frac[*b_pos];
4619 *c_pos = right_word + 1;
4645 size_t MxIndA, MxIndB, MxIndAB, MxIndC;
4646 size_t ind_c, i, ii, nc;
4647 size_t ind_as, ind_ae, ind_bs;
4652 #ifdef BIGDECIMAL_DEBUG 4654 VPrint(stdout,
"VpMult(Enter): a=% \n", a);
4655 VPrint(stdout,
" b=% \n", b);
4682 MxIndA = a->
Prec - 1;
4683 MxIndB = b->
Prec - 1;
4687 if (MxIndC < MxIndAB) {
4702 nc = ind_c = MxIndAB;
4703 memset(c->
frac, 0, (nc + 1) *
sizeof(
BDIGIT));
4705 for (nc = 0; nc < MxIndAB; ++nc, --ind_c) {
4707 ind_as = MxIndA - nc;
4711 else if (nc <= MxIndA) {
4712 ind_as = MxIndA - nc;
4713 ind_ae = MxIndA - (nc - MxIndB);
4718 ind_ae = MxIndAB - nc - 1;
4719 ind_bs = MxIndB - (nc - MxIndA);
4722 for (i = ind_as; i <= ind_ae; ++i) {
4735 c->
frac[ii] += carry;
4758 #ifdef BIGDECIMAL_DEBUG 4760 VPrint(stdout,
"VpMult(c=a*b): c=% \n", c);
4761 VPrint(stdout,
" a=% \n", a);
4762 VPrint(stdout,
" b=% \n", b);
4774 size_t word_a, word_b, word_c, word_r;
4775 size_t i, n, ind_a, ind_b, ind_c, ind_r;
4778 BDIGIT borrow, borrow1, borrow2;
4781 #ifdef BIGDECIMAL_DEBUG 4783 VPrint(stdout,
" VpDivd(c=a/b) a=% \n", a);
4784 VPrint(stdout,
" b=% \n", b);
4819 if (word_a >= word_r)
goto space_error;
4822 while (ind_r <= word_a) {
4823 r->
frac[ind_r] = a->
frac[ind_r - 1];
4827 while (ind_r < word_r) r->
frac[ind_r++] = 0;
4828 while (ind_c < word_c) c->
frac[ind_c++] = 0;
4831 b1 = b1p1 = b->
frac[0];
4833 b1b2p1 = b1b2 = b1p1 *
BASE;
4837 b1b2p1 = b1b2 = b1 *
BASE + b->
frac[1];
4838 if (b->
Prec > 2) ++b1b2p1;
4844 nLoop =
Min(word_c,ind_c);
4846 while (ind_c < nLoop) {
4847 if (r->
frac[ind_c] == 0) {
4856 while (ind_b < word_b) {
4857 if (r->
frac[ind_a] < b->
frac[ind_b])
goto div_b1p1;
4858 if (r->
frac[ind_a] > b->
frac[ind_b])
break;
4866 ind_b = b->
Prec - 1;
4867 ind_r = ind_c + ind_b;
4868 if (ind_r >= word_r)
goto space_error;
4870 for (i = 0; i <= n; ++i) {
4871 if (r->
frac[ind_r] < b->
frac[ind_b] + borrow) {
4876 r->
frac[ind_r] = r->
frac[ind_r] - b->
frac[ind_b] - borrow;
4887 if (r1r2 >= b1b2p1) {
4890 ind_r = b->
Prec + ind_c - 1;
4895 if (ind_c + 1 >= word_c)
goto out_side;
4898 ind_r = b->
Prec + ind_c;
4901 borrow1 = borrow2 = 0;
4903 if (ind_r >= word_r)
goto space_error;
4905 for (i = 0; i <= n; ++i) {
4907 qb = q * b->
frac[ind_b];
4908 if (qb <
BASE) borrow1 = 0;
4913 if(r->
frac[ind_r] < qb) {
4915 borrow2 = borrow2 + borrow1 + 1;
4922 if(r->
frac[ind_r - 1] < borrow2) {
4923 r->
frac[ind_r - 1] += (
BASE - borrow2);
4927 r->
frac[ind_r - 1] -= borrow2;
4935 r->
frac[ind_r] -= borrow2;
4961 #ifdef BIGDECIMAL_DEBUG 4963 printf(
" word_a=%"PRIuSIZE"\n", word_a);
4964 printf(
" word_b=%"PRIuSIZE"\n", word_b);
4965 printf(
" word_c=%"PRIuSIZE"\n", word_c);
4966 printf(
" word_r=%"PRIuSIZE"\n", word_r);
4967 printf(
" ind_r =%"PRIuSIZE"\n", ind_r);
4970 rb_bug(
"ERROR(VpDivd): space for remainder too small.");
4973 #ifdef BIGDECIMAL_DEBUG 4975 VPrint(stdout,
" VpDivd(c=a/b), c=% \n", c);
4976 VPrint(stdout,
" r=% \n", r);
4996 if (a->
frac[ind_a]) {
4997 a->
Prec = ind_a + 1;
4999 while (a->
frac[i] == 0) ++i;
5036 if (e > 0)
return 1;
5037 else if (e < 0)
return -1;
5042 if (e > 0)
return 1;
5098 if (val > 1) val = 1;
5099 else if (val < -1) val = -1;
5101 #ifdef BIGDECIMAL_DEBUG 5103 VPrint(stdout,
" VpComp a=%\n", a);
5104 VPrint(stdout,
" b=%\n", b);
5105 printf(
" ans=%d\n", val);
5121 #ifdef BIGDECIMAL_ENABLE_VPRINT 5123 VPrint(
FILE *fp,
const char *cntl_chr,
Real *a)
5125 size_t i, j, nc, nd, ZeroSup, sep = 10;
5133 while (*(cntl_chr + j)) {
5134 if (*(cntl_chr + j) ==
'%' && *(cntl_chr + j + 1) !=
'%') {
5153 nc += fprintf(fp,
"0.");
5154 switch (*(cntl_chr + j + 1)) {
5164 for (i = 0; i < a->
Prec; ++i) {
5169 if (!ZeroSup || nn) {
5170 nc += fprintf(fp,
"%lu", (
unsigned long)nn);
5178 nc += fprintf(fp,
" ");
5188 nc += fprintf(fp,
"0.0");
5193 if (*(cntl_chr + j) ==
'\\') {
5194 switch (*(cntl_chr + j + 1)) {
5208 fprintf(fp,
"%c", *(cntl_chr + j));
5213 fprintf(fp,
"%c", *(cntl_chr + j));
5214 if (*(cntl_chr + j) ==
'%') ++j;
5227 size_t ie, i, nf = 0;
5230 if (fFmt == 0)
return;
5233 for (i = 0; i < ie; ++i) {
5236 if (
ISSPACE(ch) || ch==
'-' || ch==
'+')
continue;
5237 if (ch ==
'.') { nf = 0;
continue; }
5238 if (ch ==
'E' || ch ==
'e')
break;
5241 memmove(psz + i + 1, psz + i, ie - i + 1);
5259 while ((a->
frac[0] / n) == 0) {
5269 size_t i, n, ZeroSup;
5289 for (i = 0; i < n; ++i) {
5294 if (!ZeroSup || nn) {
5295 sprintf(psz,
"%lu", (
unsigned long)nn);
5305 while (psz[-1] ==
'0') *(--psz) = 0;
5309 else sprintf(psz,
"-0");
5326 else if (fPlus == 2) {
5338 if (fPlus == 1) sprintf(psz,
" 0.0");
5339 else if (fPlus == 2) sprintf(psz,
"+0.0");
5340 else sprintf(psz,
"0.0");
5342 else sprintf(psz,
"-0.0");
5352 size_t i, n, ZeroSup;
5362 else if (fPlus == 1) *psz++ =
' ';
5363 else if (fPlus == 2) *psz++ =
'+';
5368 for (i = 0; i < n; ++i) {
5373 if (!ZeroSup || nn) {
5374 sprintf(psz,
"%lu", (
unsigned long)nn);
5385 while (a->
frac[0] / shift == 0) {
5389 while (psz[-1] ==
'0') {
5408 else if (fPlus == 1) *psz++ =
' ';
5409 else if (fPlus == 2) *psz++ =
'+';
5414 *psz++ =
'0';*psz++ =
'.';
5416 for (i=0; i <
BASE_FIG; ++i) *psz++ =
'0';
5422 for (i = 0; i < n; ++i) {
5424 if (i == 0 && ex >= 0) {
5425 sprintf(psz,
"%lu", (
unsigned long)a->
frac[i]);
5433 *psz++ = (char)(nn +
'0');
5438 if (ex == 0) *psz++ =
'.';
5442 while (m /= 10) *psz++ =
'0';
5443 if (ex == 0) *psz++ =
'.';
5446 while (psz[-1] ==
'0') *(--psz) = 0;
5447 if (psz[-1] ==
'.') sprintf(psz,
"0");
5465 size_t i, j, ind_a, ma, mi, me;
5467 int sign, signe, exponent_overflow;
5475 exponent_overflow = 0;
5479 if (exp_chr[0] ==
'-') {
5484 else if (exp_chr[0] ==
'+') {
5497 e = e * 10 + exp_chr[i] -
'0';
5502 exponent_overflow = 1;
5514 if (int_chr[0] ==
'-') {
5519 else if (int_chr[0] ==
'+') {
5528 if (e > 0) signe = 1;
5547 if (exponent_overflow) {
5549 for ( ; i < mi &&
zero; i++) zero = int_chr[i] ==
'0';
5550 for (i = 0; i < nf &&
zero; i++) zero = frac[i] ==
'0';
5551 if (!zero && signe > 0) {
5563 a->
frac[ind_a] = a->
frac[ind_a] * 10 + int_chr[i] -
'0';
5569 if (ind_a >= ma)
goto over_flow;
5579 a->
frac[ind_a] = a->
frac[ind_a] * 10 + frac[i] -
'0';
5585 if (ind_a >= ma)
goto over_flow;
5592 rb_warn(
"Conversion from String to BigDecimal overflow (last few digits discarded).");
5595 if (ind_a >= ma) ind_a = ma - 1;
5597 a->
frac[ind_a] = a->
frac[ind_a] * 10;
5600 a->
Prec = ind_a + 1;
5625 size_t ind_m, mm, fig;
5665 while (ind_m < mm) {
5666 div /= (double)
BASE;
5667 *d = *d + (double)m->
frac[ind_m++] * div;
5673 #ifdef BIGDECIMAL_DEBUG 5675 VPrint(stdout,
" VpVtoD: m=%\n", m);
5676 printf(
" d=%e * 10 **%ld\n", *d, *e);
5677 printf(
" DBLE_FIG = %d\n",
DBLE_FIG);
5708 val = (d > 0.) ? d : -d;
5711 while (val >= 1.0) {
5712 val /= (double)
BASE;
5717 val2 = 1.0 / (double)
BASE;
5718 while (val < val2) {
5719 val *= (double)
BASE;
5727 for (ind_m = 0; val > 0.0 && ind_m < mm; ind_m++) {
5728 val *= (double)
BASE;
5733 if (ind_m >= mm) ind_m = mm - 1;
5735 m->
Prec = ind_m + 1;
5742 #ifdef BIGDECIMAL_DEBUG 5744 printf(
"VpDtoV d=%30.30e\n", d);
5745 VPrint(stdout,
" m=%\n", m);
5759 size_t val, v1, v2, v;
5771 val =(size_t)(-ival);
5776 while (ind_m < mm) {
5785 while (v1 >=
BASE) {
5789 val = val - v2 * v1;
5799 m->
Prec = ind_m - 1;
5805 #ifdef BIGDECIMAL_DEBUG 5807 printf(
" VpItoV i=%d\n", ival);
5808 VPrint(stdout,
" m=%\n", m);
5863 prec = x->
exponent - (ssize_t)y_prec;
5872 if (e - n * 2 != 0) {
5895 #ifdef BIGDECIMAL_DEBUG 5897 printf(
"ERROR(VpSqrt): did not converge within %ld iterations.\n", nr);
5904 #ifdef BIGDECIMAL_DEBUG 5908 printf(
"VpSqrt: iterations = %"PRIdSIZE"\n", nr);
5909 VPrint(stdout,
" y =% \n", y);
5910 VPrint(stdout,
" x =% \n", x);
5911 VPrint(stdout,
" x-y*y = % \n", f);
5938 int fracf, fracf_1further;
5939 ssize_t n,i,ix,ioffset, exptoadd;
5956 if ((
size_t)ix >= y->
Prec)
return 0;
5959 ioffset = nf - ix*(ssize_t)
BASE_FIG;
5960 n = (ssize_t)
BASE_FIG - ioffset - 1;
5961 for (shifter = 1, i = 0; i < n; ++i) shifter *= 10;
5990 fracf = (v % (shifter * 10) > 0);
5991 fracf_1further = ((v % shifter) > 0);
6007 for (i = ix + 1; (size_t)i < y->Prec; i++) {
6009 fracf = fracf_1further = 1;
6020 memset(y->
frac + ix + 1, 0, (y->
Prec - (ix + 1)) *
sizeof(
BDIGIT));
6032 if (v > 5 || (v == 5 && fracf_1further)) ++
div;
6043 if (fracf_1further) {
6053 if (ix && (y->
frac[ix-1] % 2)) ++
div;
6062 for (i = 0; i <= n; ++i) div *= 10;
6083 for (i = 0; i < exptoadd; i++) {
6104 while ((v /= 10) != 0) nf--;
6113 if (
VpAsgn(y, x, 10) <= 1)
return 0;
6121 if (!
VpNmlz(c))
return -1;
6123 if (!ixDigit) ixDigit = c->
Prec-1;
6141 switch (rounding_mode) {
6166 else if (v == 5 && vPrev % 2) f = 1;
6183 if (!ind_m) ind_m = m->
Prec;
6186 while (carry > 0 && ind_m--) {
6187 m->
frac[ind_m] += carry;
6207 size_t my, ind_y, ind_x;
6232 while (ind_y < my) {
6240 #ifdef BIGDECIMAL_DEBUG 6242 VPrint(stdout,
"VpFrac y=%\n", y);
6243 VPrint(stdout,
" x=%\n", x);
6268 if (sign < 0) sign = (n % 2) ? -1 : 1;
6272 if (sign < 0) sign = (n % 2) ? -1 : 1;
6298 if ((n % 2) == 0)
goto Exit;
6303 if (n > 0) sign = 1;
6324 while (ss = s, (s += s) <= (
size_t)n) {
6333 VpDivd(w1, w2, VpConstOne, y);
6338 #ifdef BIGDECIMAL_DEBUG 6340 VPrint(stdout,
"VpPower y=%\n", y);
6341 VPrint(stdout,
"VpPower x=%\n", x);
6350 #ifdef BIGDECIMAL_DEBUG 6352 VpVarCheck(
Real * v)
6365 printf(
"ERROR(VpVarCheck): Illegal Max. Precision(=%"PRIuSIZE")\n",
6370 printf(
"ERROR(VpVarCheck): Illegal Precision(=%"PRIuSIZE")\n", v->
Prec);
6374 for (i = 0; i < v->
Prec; ++i) {
6376 printf(
"ERROR(VpVarCheck): Illegal fraction\n");
6380 printf(
" BASE =%"PRIuBDIGIT
"\n",
BASE);
static VALUE rb_rational_num(VALUE rat)
VP_EXPORT size_t VpDivd(Real *c, Real *r, Real *a, Real *b)
VP_EXPORT void VpToString(Real *a, char *psz, size_t fFmt, int fPlus)
VP_EXPORT double VpGetDoublePosInf(void)
static VALUE BigDecimal_coerce(VALUE self, VALUE other)
#define RMPD_EXCEPTION_MODE_DEFAULT
static BDIGIT VpAddAbs(Real *a, Real *b, Real *c)
static size_t VpSetPTR(Real *a, Real *b, Real *c, size_t *a_pos, size_t *b_pos, size_t *c_pos, BDIGIT *av, BDIGIT *bv)
static ID id_BigDecimal_rounding_mode
static VALUE BigDecimal_lt(VALUE self, VALUE r)
static VALUE BigDecimal_sign(VALUE self)
VP_EXPORT int VpException(unsigned short f, const char *str, int always)
void rb_bug(const char *fmt,...)
#define RUBY_TYPED_FREE_IMMEDIATELY
static VALUE BigDecimal_power(int argc, VALUE *argv, VALUE self)
static void VpFormatSt(char *psz, size_t fFmt)
static VALUE BigDecimal_load(VALUE self, VALUE str)
size_t strlen(const char *)
static VALUE BigDecimal_div3(int argc, VALUE *argv, VALUE self)
static VALUE BigDecimal_to_r(VALUE self)
VALUE rb_Rational(VALUE, VALUE)
static VALUE BigDecimal_abs(VALUE self)
static int is_zero(VALUE x)
static Real * GetVpValue(VALUE v, int must)
static unsigned int hash(str, len) register const char *str
#define BigMath_exp(x, n)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static VALUE BigDecimal_truncate(int argc, VALUE *argv, VALUE self)
VP_EXPORT int VpIsRoundMode(unsigned short n)
#define VP_SIGN_POSITIVE_FINITE
static unsigned short VpGetException(void)
void rb_big_pack(VALUE val, unsigned long *buf, long num_longs)
#define VP_SIGN_NEGATIVE_ZERO
#define TypedData_Wrap_Struct(klass, data_type, sval)
static VALUE BigDecimal_eq(VALUE self, VALUE r)
static VALUE BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod)
#define DECIMAL_SIZE_OF_BITS(n)
static VALUE ToValue(Real *p)
static VALUE BigMath_s_log(VALUE, VALUE, VALUE)
static VALUE BigDecimal_dump(int argc, VALUE *argv, VALUE self)
VALUE rb_ary_push(VALUE ary, VALUE item)
static VALUE BigDecimal_limit(int argc, VALUE *argv, VALUE self)
static VALUE BigDecimal_round(int argc, VALUE *argv, VALUE self)
if(len<=MAX_WORD_LENGTH &&len >=MIN_WORD_LENGTH)
static int VpRdup(Real *m, size_t ind_m)
RUBY_EXTERN VALUE rb_eMathDomainError
st_index_t rb_memhash(const void *ptr, long len)
static VALUE BigMath_s_exp(VALUE, VALUE, VALUE)
VP_EXPORT unsigned short VpGetRoundMode(void)
VP_EXPORT unsigned short VpSetRoundMode(unsigned short n)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
static VALUE BigDecimal_mod(VALUE self, VALUE r)
VP_EXPORT void VpDtoV(Real *m, double d)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
static void cannot_be_coerced_into_BigDecimal(VALUE exc_class, VALUE v)
void rb_raise(VALUE exc, const char *fmt,...)
VP_EXPORT void VpFrac(Real *y, Real *x)
#define VP_SIGN_POSITIVE_ZERO
static VALUE BigDecimal_sqrt(VALUE self, VALUE nFig)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
static void VpSetException(unsigned short f)
#define VP_ROUND_HALF_DOWN
#define VP_SIGN_POSITIVE_INFINITE
#define VP_EXCEPTION_OVERFLOW
#define RRATIONAL_NEGATIVE_P(x)
static VALUE BigDecimal_prec(VALUE self)
static VALUE BigDecimal_comp(VALUE self, VALUE r)
VP_EXPORT Real * VpCreateRbObject(size_t mx, const char *str)
VP_EXPORT int VpVtoD(double *d, SIGNED_VALUE *e, Real *m)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
static int is_one(VALUE x)
static VALUE BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
static VALUE BigDecimal_fix(VALUE self)
static VALUE BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
VALUE rb_str_tmp_new(long)
static void BigDecimal_delete(void *pv)
RUBY_EXTERN VALUE rb_eZeroDivError
#define DoSomeOne(x, y, f)
VP_EXPORT int VpComp(Real *a, Real *b)
static VALUE BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
static size_t GetAddSubPrec(Real *a, Real *b)
static const unsigned char dv[]
static Real * VpCopy(Real *pv, Real const *const x)
VP_EXPORT int VpMidRound(Real *y, unsigned short f, ssize_t nf)
VP_EXPORT int VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne)
VP_EXPORT int VpActiveRound(Real *y, Real *x, unsigned short f, ssize_t nf)
RUBY_EXTERN void * memmove(void *, const void *, size_t)
#define VP_EXCEPTION_INFINITY
VALUE rb_thread_local_aref(VALUE, ID)
VP_EXPORT Real * VpNewRbClass(size_t mx, const char *str, VALUE klass)
void rb_exc_raise(VALUE mesg)
static VALUE BigDecimal_mode(int argc, VALUE *argv, VALUE self)
#define VP_SIGN_NEGATIVE_FINITE
#define RB_TYPE_P(obj, type)
#define MUL_OVERFLOW_SIGNED_VALUE_P(a, b)
static size_t BigDecimal_memsize(const void *ptr)
static VALUE BigDecimal_divmod(VALUE self, VALUE r)
static VALUE BigDecimal_inspect(VALUE self)
static VALUE BigDecimal_divide(Real **c, Real **res, Real **div, VALUE self, VALUE r)
static VALUE BigDecimalCmp(VALUE self, VALUE r, char op)
static VALUE BigDecimal_neg(VALUE self)
static VALUE BigDecimal_save_rounding_mode(VALUE self)
VALUE rb_class_name(VALUE)
static VALUE BigDecimal_nonzero(VALUE self)
static int VpLimitRound(Real *c, size_t ixDigit)
VALUE rb_dbl2big(double d)
#define RMPD_COMPONENT_FIGURES
NORETURN(static void cannot_be_coerced_into_BigDecimal(VALUE, VALUE))
static VALUE BigDecimal_exponent(VALUE self)
#define VP_EXCEPTION_UNDERFLOW
static VALUE BigDecimal_remainder(VALUE self, VALUE r)
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_str_cat2(VALUE, const char *)
static VALUE BigDecimal_to_f(VALUE self)
VALUE rb_big_cmp(VALUE x, VALUE y)
#define rmpd_set_thread_local_exception_mode(mode)
VALUE rb_thread_current(void)
VP_EXPORT double VpGetDoubleNaN(void)
VP_EXPORT size_t VpGetPrecLimit(void)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static VALUE BigDecimal_div(VALUE self, VALUE r)
VP_EXPORT void * VpMemAlloc(size_t mb)
#define BDIGIT_DBL_SIGNED
void rb_define_const(VALUE, const char *, VALUE)
#define VpAllocReal(prec)
static VALUE BigDecimal_IsNaN(VALUE self)
VP_EXPORT size_t VpMult(Real *c, Real *a, Real *b)
static int VpNmlz(Real *a)
volatile const double gOne_ABCED9B4_CE73__00400511F31D
static int is_kind_of_BigDecimal(VALUE const v)
static VALUE BigDecimal_add2(VALUE self, VALUE b, VALUE n)
VP_EXPORT void VpToFString(Real *a, char *psz, size_t fFmt, int fPlus)
static VALUE BigDecimal_initialize_copy(VALUE self, VALUE other)
#define MEMCPY(p1, p2, type, n)
RUBY_EXTERN int isinf(double)
VP_EXPORT Real * VpOne(void)
#define BIGDECIMAL_POSITIVE_P(bd)
VP_EXPORT void VpSzMantissa(Real *a, char *psz)
static VALUE int_chr(int argc, VALUE *argv, VALUE num)
VALUE rb_big2str(VALUE x, int base)
static VALUE BigDecimal_version(VALUE self)
static VALUE BigDecimal_double_fig(VALUE self)
static VALUE BigDecimal_floor(int argc, VALUE *argv, VALUE self)
VP_EXPORT void VpFree(Real *pv)
void Init_bigdecimal(void)
VALUE rb_str_resize(VALUE, long)
static VALUE BigDecimal_add(VALUE self, VALUE r)
#define VP_EXCEPTION_ZERODIVIDE
static ID id_BigDecimal_exception_mode
static Real * GetVpValueWithPrec(VALUE v, long prec, int must)
static VALUE rb_rational_den(VALUE rat)
static void VpInternalRound(Real *c, size_t ixDigit, BDIGIT vPrev, BDIGIT v)
volatile const double gZero_ABCED9B1_CE73__00400511F31D
static const rb_data_type_t BigDecimal_data_type
#define VP_SIGN_NEGATIVE_INFINITE
void rb_fatal(const char *fmt,...)
static VALUE BigDecimal_uplus(VALUE self)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
VP_EXPORT Real * VpAlloc(size_t mx, const char *szVal)
#define rmpd_set_thread_local_rounding_mode(mode)
unsigned char buf[MIME_BUF_SIZE]
static VALUE BigDecimal_ge(VALUE self, VALUE r)
VALUE rb_assoc_new(VALUE car, VALUE cdr)
static VALUE BigDecimal_div2(VALUE, VALUE, VALUE)
static VALUE BigDecimal_global_new(int argc, VALUE *argv, VALUE self)
static VALUE BigDecimal_split(VALUE self)
#define VP_EXCEPTION_MEMORY
static int is_integer(VALUE x)
static ID id_BigDecimal_precision_limit
#define BIGDECIMAL_NEGATIVE_P(bd)
VP_EXPORT size_t VpInit(BDIGIT BaseVal)
static VALUE rmpd_power_by_big_decimal(Real const *x, Real const *exp, ssize_t const n)
VALUE rb_num_coerce_relop(VALUE, VALUE, ID)
static int VpIsDefOP(Real *c, Real *a, Real *b, enum op_sw sw)
static void shift(struct cparse_params *v, long act, VALUE tok, VALUE val)
RUBY_EXTERN VALUE rb_cNumeric
void rb_jump_tag(int tag)
static VALUE BigDecimal_to_i(VALUE self)
static VALUE BigDecimal_s_allocate(VALUE klass)
VP_EXPORT double VpGetDoubleNegInf(void)
register unsigned int len
static VALUE BigDecimal_zero(VALUE self)
#define StringValueCStr(v)
static VALUE BigDecimal_IsFinite(VALUE self)
VP_EXPORT size_t VpAsgn(Real *c, Real *a, int isw)
static size_t rmpd_double_figures(void)
BDIGIT frac[FLEXIBLE_ARRAY_SIZE]
#define RMPD_PRECISION_LIMIT_DEFAULT
static VALUE BigDecimal_gt(VALUE self, VALUE r)
#define rmpd_set_thread_local_precision_limit(limit)
static VALUE BigDecimal_mult(VALUE self, VALUE r)
static int is_negative(VALUE x)
VALUE rb_hash_lookup2(VALUE hash, VALUE key, VALUE def)
#define VpChangeSign(a, s)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
#define RARRAY_AREF(a, i)
RUBY_EXTERN double round(double)
#define RB_OBJ_CLASSNAME(obj)
static void BigDecimal_check_num(Real *p)
static const unsigned char cv[]
static Real * BigDecimal_new(int argc, VALUE *argv)
VP_EXPORT int VpToSpecialString(Real *a, char *psz, int fPlus)
#define RMPD_ROUNDING_MODE_DEFAULT
VP_EXPORT int VpLeftRound(Real *y, unsigned short f, ssize_t nf)
VP_EXPORT size_t VpAddSub(Real *c, Real *a, Real *b, int operation)
static VALUE BigDecimal_power_op(VALUE self, VALUE exp)
VALUE rb_check_string_type(VALUE)
static int rb_special_const_p(VALUE obj)
static int is_even(VALUE x)
void rb_thread_check_ints(void)
static VALUE BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
VP_EXPORT int VpPower(Real *y, Real *x, SIGNED_VALUE n)
#define SafeStringValue(v)
static SIGNED_VALUE GetPositiveInt(VALUE v)
static VALUE BigDecimal_initialize(int argc, VALUE *argv, VALUE self)
#define VP_ROUND_HALF_EVEN
VP_EXPORT size_t VpSetPrecLimit(size_t n)
RUBY_EXTERN VALUE rb_eFloatDomainError
#define RRATIONAL_ZERO_P(x)
#define BigMath_log(x, n)
static BDIGIT VpSubAbs(Real *a, Real *b, Real *c)
static unsigned short check_rounding_mode_option(VALUE const opts)
#define RTYPEDDATA_DATA(v)
VP_EXPORT size_t VpNumOfChars(Real *vp, const char *pszFmt)
#define rb_intern_const(str)
static VALUE BigDecimal_hash(VALUE self)
VALUE rb_define_module(const char *name)
static unsigned short check_rounding_mode(VALUE const v)
static VALUE BigDecimal_save_limit(VALUE self)
static VALUE BigDecimal_le(VALUE self, VALUE r)
static VALUE BigDecimal_save_exception_mode(VALUE self)
static int AddExponent(Real *a, SIGNED_VALUE n)
VP_EXPORT double VpGetDoubleNegZero(void)
#define VpReallocReal(ptr, prec)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void rb_warn(const char *fmt,...)
VP_EXPORT void * VpMemRealloc(void *ptr, size_t mb)
static VALUE BigDecimal_IsInfinite(VALUE self)
VP_EXPORT ssize_t VpExponent10(Real *a)
static VALUE BigDecimal_frac(VALUE self)
static VALUE BigDecimal_sub(VALUE self, VALUE r)
VALUE rb_num_coerce_cmp(VALUE, VALUE, ID)
static VALUE BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
VALUE rb_str_new(const char *, long)
VALUE rb_obj_class(VALUE)
VP_EXPORT int VpSqrt(Real *y, Real *x)