40#include <drizzled/internal/m_string.h>
48#include "drizzled/compare_double.h"
58#define DTOA_OVERFLOW 9999
60static double my_strtod_int(
const char *,
char **,
int *);
61static char *dtoa(
double,
int,
int,
int *,
int *,
char **);
94size_t my_fcvt(
double x,
int precision,
char *to,
bool *error)
96 int decpt, sign, len, i;
97 char *res, *src, *end, *dst= to;
98 assert(precision >= 0 && precision < NOT_FIXED_DEC && to != NULL);
100 res= dtoa(x, 5, precision, &decpt, &sign, &end);
102 if (decpt == DTOA_OVERFLOW)
122 for (i= decpt; i < 0; i++)
126 for (i= 1; i <= len; i++)
129 if (i == decpt && i < len)
140 for (i= precision - max(0, (len - decpt)); i > 0; i--)
216size_t my_gcvt(
double x, my_gcvt_arg_type type,
int width,
char *to,
219 int decpt, sign, len, exp_len;
220 char *res, *src, *end, *dst= to, *dend= dst + width;
221 bool have_space, force_e_format;
222 assert(width > 0 && to != NULL);
228 res= dtoa(x, 4, type == MY_GCVT_ARG_DOUBLE ? min(width, DBL_DIG) :
229 min(width, FLT_DIG), &decpt, &sign, &end);
231 if (decpt == DTOA_OVERFLOW)
252 exp_len= 1 + (decpt >= 101 || decpt <= -99) + (decpt >= 11 || decpt <= -9);
263 have_space= (decpt <= 0 ? len - decpt + 2 :
264 decpt > 0 && decpt < len ? len + 1 :
271 force_e_format= (decpt <= 0 && width <= 2 - decpt && width >= 3 + exp_len);
303 ((decpt <= width && (decpt >= -1 || (decpt == -2 &&
304 (len > 1 || !force_e_format)))) &&
311 (!have_space || (decpt >= -MAX_DECPT_FOR_F_FORMAT + 1 &&
312 (decpt <= MAX_DECPT_FOR_F_FORMAT || len > decpt))))
317 width-= (decpt < len) + (decpt <= 0 ? 1 - decpt : 0);
335 res= dtoa(x, 5, width - decpt, &decpt, &sign, &end);
351 if (sign && dst < dend)
357 if (len > 0 && dst < dend)
359 for (; decpt < 0 && dst < dend; decpt++)
363 for (i= 1; i <= len && dst < dend; i++)
366 if (i == decpt && i < len && dst < dend)
369 while (i++ <= decpt && dst < dend)
401 res= dtoa(x, 4, width, &decpt, &sign, &end);
411 if (sign && dst < dend)
415 if (len > 1 && dst < dend)
418 while (src < end && dst < dend)
423 if (decpt_sign && dst < dend)
426 if (decpt >= 100 && dst < dend)
428 *dst++= decpt / 100 +
'0';
431 *dst++= decpt / 10 +
'0';
433 else if (decpt >= 10 && dst < dend)
434 *dst++= decpt / 10 +
'0';
436 *dst++= decpt % 10 +
'0';
465double my_strtod(
const char *str,
char **end,
int *error)
468 assert(str != NULL && end != NULL && *end != NULL && error != NULL);
470 res= my_strtod_int(str, end, error);
471 return (*error == 0) ? res : (res < 0 ? -DBL_MAX : DBL_MAX);
475double my_atof(
const char *nptr)
478 const char *end= nptr+65535;
479 return (my_strtod(nptr, (
char**) &end, &error));
538typedef uint32_t ULong;
539typedef int64_t LLong;
540typedef uint64_t ULLong;
542typedef union {
double d; ULong L[2]; }
U;
544#if defined(WORDS_BIGENDIAN) || (defined(__FLOAT_WORD_ORDER) && \
545 (__FLOAT_WORD_ORDER == __BIG_ENDIAN))
546#define word0(x) ((U*)&x)->L[0]
547#define word1(x) ((U*)&x)->L[1]
549#define word0(x) ((U*)&x)->L[1]
550#define word1(x) ((U*)&x)->L[0]
553#define dval(x) ((U*)&x)->d
563#define Exp_msk1 0x100000
564#define Exp_mask 0x7ff00000
568#define Exp_1 0x3ff00000
569#define Exp_11 0x3ff00000
571#define Frac_mask 0xfffff
572#define Frac_mask1 0xfffff
575#define Bndry_mask 0xfffff
576#define Bndry_mask1 0xfffff
578#define Sign_bit 0x80000000
586#define Flt_Rounds FLT_ROUNDS
592#define rounded_product(a,b) a*= b
593#define rounded_quotient(a,b) a/= b
595#define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1))
596#define Big1 0xffffffff
597#define FFFFFFFF 0xffffffffUL
614 dst->sign= src->sign;
617 assert(dst->maxwds >= src->wds);
619 memcpy(dst->p.x, src->p.x, src->wds*
sizeof(ULong));
624static Bigint *Balloc(
int k)
627 Bigint* rv= (Bigint*) malloc(
sizeof(Bigint));
629 rv->p.x= (ULong*)malloc(x *
sizeof(ULong));
634 rv->sign= rv->wds= 0;
645static void Bfree(Bigint *v)
670 y= *x * (ULLong)m + carry;
672 *x++= (ULong)(y & FFFFFFFF);
677 if (wds >= b->maxwds)
684 b->p.x[wds++]= (ULong) carry;
691static Bigint *s2b(
const char *s,
int nd0,
int nd, ULong y9)
698 for (k= 0, y= 1; x > y; y <<= 1, k++) ;
708 b= multadd(b, 10, *s++ -
'0');
715 b= multadd(b, 10, *s++ -
'0');
720static int hi0bits(ULong x)
724 if (!(x & 0xffff0000))
729 if (!(x & 0xff000000))
734 if (!(x & 0xf0000000))
739 if (!(x & 0xc0000000))
744 if (!(x & 0x80000000))
747 if (!(x & 0x40000000))
754static int lo0bits(ULong *y)
823 ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
840 for (x= c->p.x, xa= x + wc; x < xa; x++)
847 for (; xb < xbe; xc0++)
856 z= *x++ * (ULLong)y + *xc + carry;
858 *xc++= (ULong) (z & FFFFFFFF);
864 for (xc0= c->p.x, xc= xc0 + wc; wc > 0 && !*--xc; --wc) ;
875static ULong powers5[]=
883 2242703233UL, 762134875UL, 1262UL,
885 3211403009UL, 1849224548UL, 3668416493UL, 3913284084UL, 1593091UL,
887 781532673UL, 64985353UL, 253049085UL, 594863151UL, 3553621484UL,
888 3288652808UL, 3167596762UL, 2788392729UL, 3911132675UL, 590UL,
890 2553183233UL, 3201533787UL, 3638140786UL, 303378311UL, 1809731782UL,
891 3477761648UL, 3583367183UL, 649228654UL, 2915460784UL, 487929380UL,
892 1011012442UL, 1677677582UL, 3428152256UL, 1710878487UL, 1438394610UL,
893 2161952759UL, 4100910556UL, 1608314830UL, 349175UL
900 { { powers5 }, 1, 1, 0, 1 },
901 { { powers5 + 1 }, 1, 1, 0, 1 },
902 { { powers5 + 2 }, 1, 2, 0, 2 },
903 { { powers5 + 4 }, 2, 3, 0, 3 },
904 { { powers5 + 7 }, 3, 5, 0, 5 },
905 { { powers5 + 12 }, 4, 10, 0, 10 },
906 { { powers5 + 22 }, 5, 19, 0, 19 }
909#define P5A_MAX (sizeof(p5_a)/sizeof(*p5_a) - 1)
915 static int p05[3]= { 5, 25, 125 };
918 b= multadd(b, p05[i-1], 0);
934 if (p5 < p5_a + P5A_MAX)
936 else if (p5 == p5_a + P5A_MAX)
953 ULong *x, *x1, *xe, z;
958 for (i= b->maxwds; n1 > i; i<<= 1)
962 for (i= 0; i < n; i++)
991 ULong *xa, *xa0, *xb, *xb0;
1005 return *xa < *xb ? -1 : 1;
1017 ULong *xa, *xae, *xb, *xbe, *xc;
1049 y= (ULLong)*xa++ - *xb++ - borrow;
1050 borrow= y >> 32 & (ULong)1;
1051 *xc++= (ULong) (y & FFFFFFFF);
1057 borrow= y >> 32 & (ULong)1;
1058 *xc++= (ULong) (y & FFFFFFFF);
1067static double ulp(
double x)
1072 L= (word0(x) & Exp_mask) - (P - 1)*Exp_msk1;
1079static double b2d(
Bigint *a,
int *e)
1081 ULong *xa, *xa0, w, y, z;
1094 d0= Exp_1 | y >> (Ebits - k);
1095 w= xa > xa0 ? *--xa : 0;
1096 d1= y << ((32-Ebits) + k) | w >> (Ebits - k);
1099 z= xa > xa0 ? *--xa : 0;
1102 d0= Exp_1 | y << k | z >> (32 - k);
1103 y= xa > xa0 ? *--xa : 0;
1104 d1= z << k | y >> (32 - k);
1118static Bigint *d2b(
double d,
int *e,
int *bits)
1132 if ((de= (
int)(d0 >> Exp_shift)))
1136 if ((k= lo0bits(&y)))
1138 x[0]= y | z << (32 - k);
1143 i= b->wds= (x[1]= z) ? 2 : 1;
1154 *e= de - Bias - (P-1) + k;
1159 *e= de - Bias - (P-1) + 1 + k;
1160 *bits= 32*i - hi0bits(x[i-1]);
1173 dval(da)= b2d(a, &ka);
1174 dval(db)= b2d(b, &kb);
1175 k= ka - kb + 32*(a->wds - b->wds);
1177 word0(da)+= k*Exp_msk1;
1181 word0(db)+= k*Exp_msk1;
1183 return dval(da) / dval(db);
1186static const double tens[] =
1188 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
1189 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
1193static const double bigtens[]= { 1e16, 1e32, 1e64, 1e128, 1e256 };
1194static const double tinytens[]=
1195{ 1e-16, 1e-32, 1e-64, 1e-128,
1196 9007199254740992.*9007199254740992.e-256
1202#define Scale_Bit 0x10
1234static double my_strtod_int(
const char *s00,
char **se,
int *error)
1237 int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
1238 e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
1239 const char *s, *s0, *s1, *end = *se;
1240 double aadj, aadj1, adj, rv, rv0;
1243 Bigint *bb= NULL, *bb1= NULL, *bd= NULL, *bd0= NULL, *bs= NULL, *delta= NULL;
1245 int inexact, oldinexact;
1253 for (s= s00; s < end; s++)
1278 while (++s < end && *s ==
'0') ;
1284 for (nd= nf= 0; s < end && (c= *s) >=
'0' && c <=
'9'; nd++, s++)
1290 if (s < end - 1 && c ==
'.')
1295 for (; s < end && c ==
'0'; c= *++s)
1297 if (s < end && c >
'0' && c <=
'9')
1306 for (; s < end && c >=
'0' && c <=
'9'; c = *++s)
1313 for (i= 1; i < nz; i++)
1316 else if (nd <= DBL_DIG + 1)
1320 else if (nd <= DBL_DIG + 1)
1328 if (s < end && (c ==
'e' || c ==
'E'))
1330 if (!nd && !nz && !nz0)
1342 if (s < end && c >=
'0' && c <=
'9')
1344 while (s < end && c ==
'0')
1346 if (s < end && c >
'0' && c <=
'9') {
1349 while (++s < end && (c= *s) >=
'0' && c <=
'9')
1351 if (s - s1 > 8 || L > 19999)
1388 k= nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
1394 oldinexact = get_inexact();
1396 dval(rv)= tens[k - 9] * dval(rv) + z;
1408 rounded_product(dval(rv), tens[e]);
1412 if (e <= Ten_pmax + i)
1420 rounded_product(dval(rv), tens[e]);
1424#ifndef Inaccurate_Divide
1425 else if (e >= -Ten_pmax)
1427 rounded_quotient(dval(rv), tens[-e]);
1437 oldinexact= get_inexact();
1449 if (e1 > DBL_MAX_10_EXP)
1454 word0(rv)= Exp_mask;
1459 dval(rv0)*= dval(rv0);
1466 for(j= 0; e1 > 1; j++, e1>>= 1)
1468 dval(rv)*= bigtens[j];
1470 word0(rv)-= P*Exp_msk1;
1471 dval(rv)*= bigtens[j];
1472 if ((z= word0(rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
1474 if (z > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P))
1481 word0(rv)+= P*Exp_msk1;
1491 if (e1 >= 1 << n_bigtens)
1495 for(j= 0; e1 > 0; j++, e1>>= 1)
1497 dval(rv)*= tinytens[j];
1498 if (scale && (j = 2 * P + 1 - ((word0(rv) & Exp_mask) >> Exp_shift)) > 0)
1505 word0(rv)= (P + 2) * Exp_msk1;
1507 word0(rv)&= 0xffffffff << (j - 32);
1510 word1(rv)&= 0xffffffff << j;
1512 if (compare_double(dval(rv), 0))
1527 bd0= s2b(s0, nd0, nd, y);
1533 bb= d2b(dval(rv), &bbe, &bbbits);
1560 i= bb2 < bd2 ? bb2 : bd2;
1571 bs= pow5mult(bs, bb5);
1577 bb= lshift(bb, bb2);
1579 bd= pow5mult(bd, bd5);
1581 bd= lshift(bd, bd2);
1583 bs= lshift(bs, bs2);
1584 delta= diff(bb, bd);
1595 if (dsign || word1(rv) || word0(rv) & Bndry_mask ||
1596 (word0(rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1)
1599 if (!delta->x[0] && delta->wds <= 1)
1604 if (!delta->p.x[0] && delta->wds <= 1)
1612 delta= lshift(delta, Log2P);
1613 if (cmp(delta, bs) > 0)
1622 if ((word0(rv) & Bndry_mask1) == Bndry_mask1 &&
1624 ((scale && (y = word0(rv) & Exp_mask) <= 2 * P * Exp_msk1) ?
1625 (0xffffffff & (0xffffffff << (2*P+1-(y>>Exp_shift)))) :
1629 word0(rv)= (word0(rv) & Exp_mask) + Exp_msk1;
1635 else if (!(word0(rv) & Bndry_mask) && !word1(rv))
1641 L= word0(rv) & Exp_mask;
1642 if (L <= (2 *P + 1) * Exp_msk1)
1644 if (L > (P + 2) * Exp_msk1)
1651 L= (word0(rv) & Exp_mask) - Exp_msk1;
1652 word0(rv)= L | Bndry_mask1;
1653 word1(rv)= 0xffffffff;
1656 if (!(word1(rv) & LSB))
1659 dval(rv)+= ulp(dval(rv));
1662 dval(rv)-= ulp(dval(rv));
1669 if ((aadj= ratio(delta, bs)) <= 2.)
1673 else if (word1(rv) || word0(rv) & Bndry_mask)
1675 if (word1(rv) == Tiny1 && !word0(rv))
1683 if (aadj < 2. / FLT_RADIX)
1684 aadj= 1. / FLT_RADIX;
1693 aadj1= dsign ? aadj : -aadj;
1694 if (Flt_Rounds == 0)
1697 y= word0(rv) & Exp_mask;
1701 if (y == Exp_msk1 * (DBL_MAX_EXP + Bias - 1))
1703 dval(rv0)= dval(rv);
1704 word0(rv)-= P * Exp_msk1;
1705 adj= aadj1 * ulp(dval(rv));
1707 if ((word0(rv) & Exp_mask) >= Exp_msk1 * (DBL_MAX_EXP + Bias - P))
1709 if (word0(rv0) == Big0 && word1(rv0) == Big1)
1716 word0(rv)+= P * Exp_msk1;
1720 if (scale && y <= 2 * P * Exp_msk1)
1722 if (aadj <= 0x7fffffff)
1724 if ((z= (ULong) aadj) <= 0)
1727 aadj1= dsign ? aadj : -aadj;
1729 word0(aadj1)+= (2 * P + 1) * Exp_msk1 - y;
1731 adj = aadj1 * ulp(dval(rv));
1734 z= word0(rv) & Exp_mask;
1743 if (dsign || word1(rv) || word0(rv) & Bndry_mask)
1745 if (aadj < .4999999 || aadj > .5000001)
1748 else if (aadj < .4999999 / FLT_RADIX)
1763 word0(rv0)= Exp_1 + (70 << Exp_shift);
1768 else if (!oldinexact)
1773 word0(rv0)= Exp_1 - 2 * P * Exp_msk1;
1775 dval(rv)*= dval(rv0);
1778 if (inexact && !(word0(rv) & Exp_mask))
1782 dval(rv0)*= dval(rv0);
1793 return sign ? -dval(rv) : dval(rv);
1800 ULong *bx, *bxe, q, *sx, *sxe;
1801 ULLong borrow, carry, y, ys;
1810 q= *bxe / (*sxe + 1);
1817 ys= *sx++ * (ULLong)q + carry;
1819 y= *bx - (ys & FFFFFFFF) - borrow;
1820 borrow= y >> 32 & (ULong)1;
1821 *bx++= (ULong) (y & FFFFFFFF);
1827 while (--bxe > bx && !*bxe)
1843 y= *bx - (ys & FFFFFFFF) - borrow;
1844 borrow= y >> 32 & (ULong)1;
1845 *bx++= (ULong) (y & FFFFFFFF);
1852 while (--bxe > bx && !*bxe)
1896static char *dtoa(
double d,
int mode,
int ndigits,
int *decpt,
int *sign,
1932 int bbits, b2, b5, be, dig, i, ieps, ilim=0, ilim0, ilim1= 0,
1933 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
1934 spec_case, try_quick;
1938 Bigint *b, *b1, *delta, *mlo = NULL, *mhi, *S;
1942 if (word0(d) & Sign_bit)
1946 word0(d) &= ~Sign_bit;
1952 if ((((word0(d) & Exp_mask) == Exp_mask) && ((*decpt= DTOA_OVERFLOW) != 0)) ||
1953 (!dval(d) && ((*decpt= 1) != 0)))
1956 char *res= (
char*) malloc(2);
1965 b= d2b(dval(d), &be, &bbits);
1966 if ((i= (
int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))))
1969 word0(d2) &= Frac_mask1;
1970 word0(d2) |= Exp_11;
2002 i= bbits + be + (Bias + (P-1) - 1);
2003 x= i > 32 ? word0(d) << (64 - i) | word1(d) >> (i - 32)
2004 : word1(d) << (32 - i);
2006 word0(d2)-= 31*Exp_msk1;
2007 i-= (Bias + (P-1) - 1) + 1;
2010 ds= (dval(d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
2012 if (ds < 0. && ds != k)
2015 if (k >= 0 && k <= Ten_pmax)
2017 if (dval(d) < tens[k])
2044 if (mode < 0 || mode > 9)
2068 ilim= ilim1= i= ndigits;
2080 s= s0= (
char*)malloc(i+1);
2083 if (ilim >= 0 && ilim <= Quick_max && try_quick)
2099 dval(d)/= bigtens[n_bigtens-1];
2102 for (; j; j>>= 1, i++)
2114 dval(d)*= tens[j1 & 0xf];
2115 for (j= j1 >> 4; j; j>>= 1, i++)
2120 dval(d)*= bigtens[i];
2124 if (k_check && dval(d) < 1. && ilim > 0)
2133 dval(eps)= ieps*dval(d) + 7.;
2134 word0(eps)-= (P-1)*Exp_msk1;
2139 if (dval(d) > dval(eps))
2141 if (dval(d) < -dval(eps))
2148 dval(eps)= 0.5/tens[ilim-1] - dval(eps);
2154 if (dval(d) < dval(eps))
2156 if (1. - dval(d) < dval(eps))
2167 dval(eps)*= tens[ilim-1];
2168 for (i= 1;; i++, dval(d)*= 10.)
2176 if (dval(d) > 0.5 + dval(eps))
2178 else if (dval(d) < 0.5 - dval(eps))
2180 while (*--s ==
'0') {}
2197 if (be >= 0 && k <= Int_max)
2201 if (ndigits < 0 && ilim <= 0)
2204 if (ilim < 0 || dval(d) <= 5*ds)
2208 for (i= 1;; i++, dval(d)*= 10.)
2210 L= (Long)(dval(d) / ds);
2220 if (dval(d) > ds || (dval(d) == ds && L & 1))
2243 i = denorm ? be + (Bias + (P-1) - 1 + 1) : 1 + P - bbits;
2248 if (m2 > 0 && s2 > 0)
2250 i= m2 < s2 ? m2 : s2;
2261 mhi= pow5mult(mhi, m5);
2279 if ((mode < 2 || leftright)
2282 if (!word1(d) && !(word0(d) & Bndry_mask) &&
2283 word0(d) & (Exp_mask & ~Exp_msk1)
2301 if ((i= ((s5 ? 32 - hi0bits(S->p.x[S->wds-1]) : 1) + s2) & 0x1f))
2327 b= multadd(b, 10, 0);
2329 mhi= multadd(mhi, 10, 0);
2333 if (ilim <= 0 && (mode == 3 || mode == 5))
2335 if (ilim < 0 || cmp(b,S= multadd(S,5,0)) <= 0)
2350 mhi= lshift(mhi, m2);
2359 mhi= Balloc(mhi->k);
2361 mhi= lshift(mhi, Log2P);
2366 dig= quorem(b,S) +
'0';
2369 delta= diff(S, mhi);
2370 j1= delta->sign ? 1 : cmp(b, delta);
2372 if (j1 == 0 && mode != 1 && !(word1(d) & 1)
2382 if (j < 0 || (j == 0 && mode != 1 && !(word1(d) & 1)))
2384 if (!b->p.x[0] && b->wds <= 1)
2392 if ((j1 > 0 || (j1 == 0 && dig & 1))
2414 b= multadd(b, 10, 0);
2416 mlo= mhi= multadd(mhi, 10, 0);
2419 mlo= multadd(mlo, 10, 0);
2420 mhi= multadd(mhi, 10, 0);
2427 *s++= dig= quorem(b,S) +
'0';
2428 if (!b->p.x[0] && b->wds <= 1)
2434 b= multadd(b, 10, 0);
2441 if (j > 0 || (j == 0 && dig & 1))
2455 while (*--s ==
'0') {}
2462 if (mlo && mlo != mhi)
TODO: Rename this file - func.h is stupid.