← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mystrings/decimal.c

  • Committer: Monty Taylor
  • Date: 2008-09-22 23:53:43 UTC
  • mto: This revision was merged to the branch mainline in revision 417.
  • Revision ID: monty@inaugust.com-20080922235343-ihqvp6g9k1mtzxmc
Renamed max/min.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mystrings/decimal.c
404
404
    for (; frac>0; frac-=DIG_PER_DEC1)
405
405
    {
406
406
      dec1 x=*buf++;
407
 
      for (i=min(frac, DIG_PER_DEC1); i; i--)
 
407
      for (i=cmin(frac, DIG_PER_DEC1); i; i--)
408
408
      {
409
409
        dec1 y=x/DIG_MASK;
410
410
        *s1++='0'+(uchar)y;
427
427
    for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1)
428
428
    {
429
429
      dec1 x=*--buf;
430
 
      for (i=min(intg, DIG_PER_DEC1); i; i--)
 
430
      for (i=cmin(intg, DIG_PER_DEC1); i; i--)
431
431
      {
432
432
        dec1 y=x/10;
433
433
        *--s='0'+(uchar)(x-y*10);
1501
1501
 
1502
1502
  if (to != from || intg1>intg0)
1503
1503
  {
1504
 
    dec1 *p0= buf0+intg0+max(frac1, frac0);
1505
 
    dec1 *p1= buf1+intg1+max(frac1, frac0);
 
1504
    dec1 *p0= buf0+intg0+cmax(frac1, frac0);
 
1505
    dec1 *p1= buf1+intg1+cmax(frac1, frac0);
1506
1506
 
1507
1507
    while (buf0 < p0)
1508
1508
      *(--p1) = *(--p0);
1513
1513
    buf0=to->buf;
1514
1514
    buf1=to->buf;
1515
1515
    to->sign=from->sign;
1516
 
    to->intg=min(intg0, len)*DIG_PER_DEC1;
 
1516
    to->intg=cmin(intg0, len)*DIG_PER_DEC1;
1517
1517
  }
1518
1518
 
1519
1519
  if (frac0 > frac1)
1615
1615
        scale=frac0*DIG_PER_DEC1;
1616
1616
        error=E_DEC_TRUNCATED; /* XXX */
1617
1617
      }
1618
 
      for (buf1=to->buf+intg0+max(frac0,0); buf1 > to->buf; buf1--)
 
1618
      for (buf1=to->buf+intg0+cmax(frac0,0); buf1 > to->buf; buf1--)
1619
1619
      {
1620
1620
        buf1[0]=buf1[-1];
1621
1621
      }
1634
1634
        /* making 'zero' with the proper scale */
1635
1635
        dec1 *p0= to->buf + frac0 + 1;
1636
1636
        to->intg=1;
1637
 
        to->frac= max(scale, 0);
 
1637
        to->frac= cmax(scale, 0);
1638
1638
        to->sign= 0;
1639
1639
        for (buf1= to->buf; buf1<p0; buf1++)
1640
1640
          *buf1= 0;
1683
1683
{
1684
1684
  switch (op) {
1685
1685
  case '-':
1686
 
    return ROUND_UP(max(from1->intg, from2->intg)) +
1687
 
           ROUND_UP(max(from1->frac, from2->frac));
 
1686
    return ROUND_UP(cmax(from1->intg, from2->intg)) +
 
1687
           ROUND_UP(cmax(from1->frac, from2->frac));
1688
1688
  case '+':
1689
 
    return ROUND_UP(max(from1->intg, from2->intg)+1) +
1690
 
           ROUND_UP(max(from1->frac, from2->frac));
 
1689
    return ROUND_UP(cmax(from1->intg, from2->intg)+1) +
 
1690
           ROUND_UP(cmax(from1->frac, from2->frac));
1691
1691
  case '*':
1692
1692
    return ROUND_UP(from1->intg+from2->intg)+
1693
1693
           ROUND_UP(from1->frac)+ROUND_UP(from2->frac);
1702
1702
{
1703
1703
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1704
1704
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac),
1705
 
      frac0=max(frac1, frac2), intg0=max(intg1, intg2), error;
 
1705
      frac0=cmax(frac1, frac2), intg0=cmax(intg1, intg2), error;
1706
1706
  dec1 *buf1, *buf2, *buf0, *stop, *stop2, x, carry;
1707
1707
 
1708
1708
  sanity(to);
1727
1727
  buf0=to->buf+intg0+frac0;
1728
1728
 
1729
1729
  to->sign=from1->sign;
1730
 
  to->frac=max(from1->frac, from2->frac);
 
1730
  to->frac=cmax(from1->frac, from2->frac);
1731
1731
  to->intg=intg0*DIG_PER_DEC1;
1732
1732
  if (unlikely(error))
1733
1733
  {
1738
1738
    set_if_smaller(intg2, intg0);
1739
1739
  }
1740
1740
 
1741
 
  /* part 1 - max(frac) ... min (frac) */
 
1741
  /* part 1 - cmax(frac) ... cmin(frac) */
1742
1742
  if (frac1 > frac2)
1743
1743
  {
1744
1744
    buf1=from1->buf+intg1+frac1;
1756
1756
  while (buf1 > stop)
1757
1757
    *--buf0=*--buf1;
1758
1758
 
1759
 
  /* part 2 - min(frac) ... min(intg) */
 
1759
  /* part 2 - cmin(frac) ... cmin(intg) */
1760
1760
  carry=0;
1761
1761
  while (buf1 > stop2)
1762
1762
  {
1763
1763
    ADD(*--buf0, *--buf1, *--buf2, carry);
1764
1764
  }
1765
1765
 
1766
 
  /* part 3 - min(intg) ... max(intg) */
 
1766
  /* part 3 - cmin(intg) ... cmax(intg) */
1767
1767
  buf1= intg1 > intg2 ? ((stop=from1->buf)+intg1-intg2) :
1768
1768
                        ((stop=from2->buf)+intg2-intg1) ;
1769
1769
  while (buf1 > stop)
1784
1784
{
1785
1785
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
1786
1786
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac);
1787
 
  int frac0=max(frac1, frac2), error;
 
1787
  int frac0=cmax(frac1, frac2), error;
1788
1788
  dec1 *buf1, *buf2, *buf0, *stop1, *stop2, *start1, *start2, carry=0;
1789
1789
 
1790
1790
  /* let carry:=1 if from2 > from1 */
1859
1859
  FIX_INTG_FRAC_ERROR(to->len, intg1, frac0, error);
1860
1860
  buf0=to->buf+intg1+frac0;
1861
1861
 
1862
 
  to->frac=max(from1->frac, from2->frac);
 
1862
  to->frac=cmax(from1->frac, from2->frac);
1863
1863
  to->intg=intg1*DIG_PER_DEC1;
1864
1864
  if (unlikely(error))
1865
1865
  {
1870
1870
  }
1871
1871
  carry=0;
1872
1872
 
1873
 
  /* part 1 - max(frac) ... min (frac) */
 
1873
  /* part 1 - cmax(frac) ... cmin(frac) */
1874
1874
  if (frac1 > frac2)
1875
1875
  {
1876
1876
    buf1=start1+intg1+frac1;
1894
1894
    }
1895
1895
  }
1896
1896
 
1897
 
  /* part 2 - min(frac) ... intg2 */
 
1897
  /* part 2 - cmin(frac) ... intg2 */
1898
1898
  while (buf2 > start2)
1899
1899
  {
1900
1900
    SUB(*--buf0, *--buf1, *--buf2, carry);
2150
2150
  {
2151
2151
    /* we're calculating N1 % N2.
2152
2152
       The result will have
2153
 
         frac=max(frac1, frac2), as for subtraction
 
2153
         frac=cmax(frac1, frac2), as for subtraction
2154
2154
         intg=intg2
2155
2155
    */
2156
2156
    to->sign=from1->sign;
2157
 
    to->frac=max(from1->frac, from2->frac);
 
2157
    to->frac=cmax(from1->frac, from2->frac);
2158
2158
    frac0=0;
2159
2159
  }
2160
2160
  else
2278
2278
    /*
2279
2279
      now the result is in tmp1, it has
2280
2280
        intg=prec1-frac1
2281
 
        frac=max(frac1, frac2)=to->frac
 
2281
        frac=cmax(frac1, frac2)=to->frac
2282
2282
    */
2283
2283
    if (dcarry)
2284
2284
      *--start1=dcarry;
2316
2316
      }
2317
2317
      assert(intg0 <= ROUND_UP(from2->intg));
2318
2318
      stop1=start1+frac0+intg0;
2319
 
      to->intg=min(intg0*DIG_PER_DEC1, from2->intg);
 
2319
      to->intg=cmin(intg0*DIG_PER_DEC1, from2->intg);
2320
2320
    }
2321
2321
    if (unlikely(intg0+frac0 > to->len))
2322
2322
    {