← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/decimal.cc

  • Committer: Nathan Williams
  • Date: 2009-07-02 06:54:37 UTC
  • mfrom: (1085 staging)
  • mto: This revision was merged to the branch mainline in revision 1087.
  • Revision ID: nathanlws@gmail.com-20090702065437-nmgxvuk837rpa3e0
Merged trunk, resolved conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/decimal.cc
107
107
#include <drizzled/util/test.h>
108
108
 
109
109
#include <alloca.h>
 
110
 
 
111
#include <algorithm>
 
112
 
 
113
using namespace std;
 
114
 
 
115
 
110
116
/*
111
117
  Internally decimal numbers are stored base 10^9 (see DIG_BASE below)
112
118
  So one variable of type decimal_digit_t is limited:
407
413
    for (; frac>0; frac-=DIG_PER_DEC1)
408
414
    {
409
415
      dec1 x=*buf++;
410
 
      for (i=cmin(frac, DIG_PER_DEC1); i; i--)
 
416
      for (i=min(frac, DIG_PER_DEC1); i; i--)
411
417
      {
412
418
        dec1 y=x/DIG_MASK;
413
419
        *s1++='0'+(unsigned char)y;
430
436
    for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1)
431
437
    {
432
438
      dec1 x=*--buf;
433
 
      for (i=cmin(intg, DIG_PER_DEC1); i; i--)
 
439
      for (i=min(intg, DIG_PER_DEC1); i; i--)
434
440
      {
435
441
        dec1 y=x/10;
436
442
        *--s='0'+(unsigned char)(x-y*10);
1504
1510
 
1505
1511
  if (to != from || intg1>intg0)
1506
1512
  {
1507
 
    dec1 *p0= buf0+intg0+cmax(frac1, frac0);
1508
 
    dec1 *p1= buf1+intg1+cmax(frac1, frac0);
 
1513
    dec1 *p0= buf0+intg0+max(frac1, frac0);
 
1514
    dec1 *p1= buf1+intg1+max(frac1, frac0);
1509
1515
 
1510
1516
    while (buf0 < p0)
1511
1517
      *(--p1) = *(--p0);
1516
1522
    buf0=to->buf;
1517
1523
    buf1=to->buf;
1518
1524
    to->sign=from->sign;
1519
 
    to->intg=cmin(intg0, len)*DIG_PER_DEC1;
 
1525
    to->intg=min(intg0, len)*DIG_PER_DEC1;
1520
1526
  }
1521
1527
 
1522
1528
  if (frac0 > frac1)
1618
1624
        scale=frac0*DIG_PER_DEC1;
1619
1625
        error=E_DEC_TRUNCATED; /* XXX */
1620
1626
      }
1621
 
      for (buf1=to->buf+intg0+cmax(frac0,0); buf1 > to->buf; buf1--)
 
1627
      for (buf1=to->buf+intg0+max(frac0,0); buf1 > to->buf; buf1--)
1622
1628
      {
1623
1629
        buf1[0]=buf1[-1];
1624
1630
      }
1637
1643
        /* making 'zero' with the proper scale */
1638
1644
        dec1 *p0= to->buf + frac0 + 1;
1639
1645
        to->intg=1;
1640
 
        to->frac= cmax(scale, 0);
 
1646
        to->frac= max(scale, 0);
1641
1647
        to->sign= 0;
1642
1648
        for (buf1= to->buf; buf1<p0; buf1++)
1643
1649
          *buf1= 0;
1686
1692
{
1687
1693
  switch (op) {
1688
1694
  case '-':
1689
 
    return ROUND_UP(cmax(from1->intg, from2->intg)) +
1690
 
           ROUND_UP(cmax(from1->frac, from2->frac));
 
1695
    return ROUND_UP(max(from1->intg, from2->intg)) +
 
1696
           ROUND_UP(max(from1->frac, from2->frac));
1691
1697
  case '+':
1692
 
    return ROUND_UP(cmax(from1->intg, from2->intg)+1) +
1693
 
           ROUND_UP(cmax(from1->frac, from2->frac));
 
1698
    return ROUND_UP(max(from1->intg, from2->intg)+1) +
 
1699
           ROUND_UP(max(from1->frac, from2->frac));
1694
1700
  case '*':
1695
1701
    return ROUND_UP(from1->intg+from2->intg)+
1696
1702
           ROUND_UP(from1->frac)+ROUND_UP(from2->frac);
1705
1711
{
1706
1712
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1707
1713
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac),
1708
 
      frac0=cmax(frac1, frac2), intg0=cmax(intg1, intg2), error;
 
1714
      frac0=max(frac1, frac2), intg0=max(intg1, intg2), error;
1709
1715
  dec1 *buf1, *buf2, *buf0, *stop, *stop2, x, carry;
1710
1716
 
1711
1717
  sanity(to);
1730
1736
  buf0=to->buf+intg0+frac0;
1731
1737
 
1732
1738
  to->sign=from1->sign;
1733
 
  to->frac=cmax(from1->frac, from2->frac);
 
1739
  to->frac=max(from1->frac, from2->frac);
1734
1740
  to->intg=intg0*DIG_PER_DEC1;
1735
1741
  if (unlikely(error))
1736
1742
  {
1787
1793
{
1788
1794
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1789
1795
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac);
1790
 
  int frac0=cmax(frac1, frac2), error;
 
1796
  int frac0=max(frac1, frac2), error;
1791
1797
  dec1 *buf1, *buf2, *buf0, *stop1, *stop2, *start1, *start2, carry=0;
1792
1798
 
1793
1799
  /* let carry:=1 if from2 > from1 */
1862
1868
  FIX_INTG_FRAC_ERROR(to->len, intg1, frac0, error);
1863
1869
  buf0=to->buf+intg1+frac0;
1864
1870
 
1865
 
  to->frac=cmax(from1->frac, from2->frac);
 
1871
  to->frac=max(from1->frac, from2->frac);
1866
1872
  to->intg=intg1*DIG_PER_DEC1;
1867
1873
  if (unlikely(error))
1868
1874
  {
2157
2163
         intg=intg2
2158
2164
    */
2159
2165
    to->sign=from1->sign;
2160
 
    to->frac=cmax(from1->frac, from2->frac);
 
2166
    to->frac=max(from1->frac, from2->frac);
2161
2167
    frac0=0;
2162
2168
  }
2163
2169
  else
2319
2325
      }
2320
2326
      assert(intg0 <= ROUND_UP(from2->intg));
2321
2327
      stop1=start1+frac0+intg0;
2322
 
      to->intg=cmin(intg0*DIG_PER_DEC1, from2->intg);
 
2328
      to->intg=min(intg0*DIG_PER_DEC1, from2->intg);
2323
2329
    }
2324
2330
    if (unlikely(intg0+frac0 > to->len))
2325
2331
    {