home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / C / MONEY / MONEY.C next >
C/C++ Source or Header  |  1992-12-17  |  8KB  |  308 lines
  1. /* @(#) money.c                     1991 Adolfo Di Mare  */
  2. /*                                       adimare@UCRVM2  */
  3. /*                                                       */
  4. /*                Test driver for money.h                */
  5. /*                                                       */
  6. /* Compiler:                           Borland C++ v 2.0 */
  7. /*                          [should work with Turbo C++] */
  8.  
  9. /*
  10.    To see what is going on, you need to use your symbolic
  11.    debugger to examine each of the declared variables.
  12.  
  13.    For Borland C++, I used the following watches:
  14.  
  15.         m_money      d,f18
  16.         m,r          i
  17.         mm,r         l
  18.         elapsed      s,f18
  19.  
  20.    Change the compile time macros to see how money's
  21.    change their behaviour.
  22.  
  23. */
  24.  
  25. #define TEST
  26.  
  27. #ifdef  TEST /* { */
  28.  
  29. #if 0
  30.   #define MONEY_ROUNDING    /* Force rounding of doubles */
  31. #endif
  32.  
  33. #define MONEY_DECIMALS  2   /* 2 decimals for money data */
  34.  
  35. extern "C++" {
  36.     #include "money.h"
  37.  
  38.     #ifdef __TURBOC__
  39.     #include <iostream.h>
  40.     #else
  41.     #include <stream.h>
  42.     #endif
  43. }
  44.  
  45. inline ostream& operator<<(ostream &out, money& m) {
  46.     return out << (double) m;
  47. }
  48.  
  49. extern "C" {
  50.     #include <stdlib.h>
  51.     #include <time.h>
  52.     #include <stdio.h>
  53. }
  54.  
  55. #define RANGER
  56. #undef  RANGER           /* takes forever to run...   */
  57.  
  58. void ranger(void);
  59.  
  60. void main(void) {
  61.  
  62.     // To the right is the assigned value
  63.  
  64.     money m(25.8499); // $  25.84
  65.     money mm;         // $ #$$#@$@.98
  66.  
  67.     int     i = 5;    //     5
  68.     long    l = 6;    //     7
  69.     double  d = m;    //    25.8399999999999999999999999999
  70.  
  71.     i  = m;           //    25
  72. #if 0     /* [ */
  73.     m  = d;           // $  25.84
  74.     m  = 7.009999999; // $   7.oo
  75.     m += 1;           // $   8.oo
  76.     m += 1.245000001; // $   9.24
  77.     m += 1L;          // $  10.24
  78.     m += 'a';         // $  'a'+10.24
  79.  
  80.     m  = -d;          // $ -25.84
  81.     m  = -7.00999999; // $ - 7.oo
  82.     m -= 1;           // $ - 8.oo
  83.     m -= 1.245000001; // $ - 9.24
  84.     m -= 1L;          // $ -10.24
  85.     m -= 'a';         // $ -'a'-10.24
  86.  
  87.     mm = 10;          // $  10.oo
  88.     m  = mm+4;        // $  14.oo
  89.     m  = mm+4.014999; // $  14.01
  90.     m  = 4.99+mm;     // $  14.99
  91.     m  = 4+mm;        // $  14.oo
  92.     m  = m+mm;        // $  24.oo
  93.     m += m;           // $  48.oo
  94.  
  95.     d  = mm+4;        //    14.oo
  96.     d  = mm+4.011;    //    14.0099999999999998
  97.     d  = 4.99+mm;     //    14.9900000000000002
  98.     d  = 4+mm;        //    14.oo
  99.  
  100.     mm = 10;          // $  10.oo
  101.     m  = mm*4;        // $  40.oo
  102.     m  = mm*4.0;      // $  40.oo
  103.     m  = 4*mm;        // $  40.oo
  104.     m  = 4.0*mm;      // $  40.oo
  105.  
  106.     mm = 10;          // $  10.oo
  107.     d  =  7.00001;    //     7.00000999999999962
  108.     m  = d*mm+d;      // $  77.oo
  109.     m  = (d*mm)+d;    // $  77.oo
  110.     m  = d+d*mm;      // $  77.oo
  111.     m  = d+(d*mm);    // $  77.oo
  112.  
  113.     m = 10;           // $  10.oo
  114.             mm = 77;  // $  77.oo
  115.     m = m % mm;       // $  10.oo
  116.     // $10 == 0L * $77 + [$10]
  117.  
  118.     m = 77;           // $  77.oo
  119.              mm = 10; // $  10.oo
  120.     m = m % mm;       // $   7.oo
  121.     // $77 == 7L * $10 + [$7]
  122.  
  123.     m++;              // $   8.oo
  124.     m--;              // $   7.oo
  125.  
  126.     m   = 11.75;                // $  11.75
  127.     m  +=  0.12;                // $  11.87
  128.     mm  = flatten(m,0.25,1);    // $  11.75
  129.  
  130.     m  += 0.01;                 // $  11.88
  131.     mm  = flatten(m,0.25,1);    // $  12.oo
  132.  
  133.     m   = 11.75;                // $  11.75
  134.     m  +=  0.12;                // $  11.87
  135.     mm  = flatten(m,0.25,0);    // $  11.75
  136.  
  137.     m  += 0.01;                 // $  11.88
  138.     mm  = flatten(m,0.25,0);    // $  11.75
  139.  
  140.     m  -= 5;
  141.     m  += 0.12;                 // $   7.oo
  142.     if (m == 0 || 0 == m) {     // nep
  143.         m += d;
  144.     }
  145.     else if (!(m == m)) {       // nep
  146.         m = m;
  147.     }
  148.     else if (m > m) {           // nep
  149.         m = m;
  150.     }
  151.     else if (m < m) {           // nep
  152.         m = m;
  153.     }
  154.     else if (m != m) {          // nep
  155.         m = m;
  156.     }
  157.     else if (m >= m) {          // yep
  158.         m *= 11;      // $  77.oo
  159.         m += 15;      // $  92.oo
  160.     }
  161.     l  = i = m;       //    92
  162.     m  = -m;          // $ -92.oo
  163.     mm = i*l;         // $   8,464.oo
  164.     m  = m % mm;      // $ -92.oo
  165.  
  166.     d  = 15.253;      //   15.253
  167.     m  = 15.25;       // $ 15.25
  168.  
  169.     if (d == m) {          // FALSE: float comparison...
  170.         l = 0;
  171.     }                      // l = 92L
  172.     if (d == (double) m) { // FALSE: 15.253 != 15.25
  173.         l++;
  174.     }                      // l = 92L
  175.  
  176.     // simulate a TAX calculation
  177.     m = 0.0;
  178.     for (i = 1; i <= 100; i++) {
  179.         d  = i*1.005;    // 0.05% tax
  180.         m += d;
  181.     }                    // $ 5,075.oo
  182.     mm = 100;            // $   100.oo
  183.     m /= (double) mm;    // $    50.75
  184.     m /=   3;            // $    16.91
  185.     m *=   3;            // $    50.73
  186.  
  187.     mm = mm/mm;          //       1.00
  188.     d  = m * (m / mm);   //    2573.5300000000002
  189.  
  190.     d  = 1.0/3.0 * m;    //      16.9100000000000001
  191.     mm = 1.0/3.0 * m;    // $    16.91
  192.  
  193.     mm = 3 * mm / (3 * mm);                  // $1.oo
  194.     mm = M_PI * mm / (M_PI * mm);            // $1.oo
  195.     mm = M_PI;                               // $3.14
  196.  
  197.     mm = mm/mm + 1 - (3 * mm / (3 * mm));    // $1.oo
  198.     m *= M_E * mm / (mm * M_E) - 1;          // $0.oo
  199.  
  200.     // m == 0.0 && mm == $1.oo
  201.     for (i = 1; i <= 100; i++) {
  202.         mm /= 3;          // $    0.33
  203.         m   = m+mm;       // Add a third
  204.         mm  = 1;
  205.     }                     // $    33.oo
  206.  
  207.     d  = m;               //      33.00
  208.     mm = m / 330;         // $     0.10
  209.  
  210.     clock_t now;
  211.     double  elapsed;
  212.  
  213.     // time statistics, on an 33MHz 386
  214.     m = 0;
  215.     now = clock();
  216.     for (l = 0; l <= 10000l; l++) {
  217.         m += 1.01;          // Add $1.01
  218.     }
  219.     elapsed = (clock()-now) / CLK_TCK;
  220.     d  = elapsed;           // 3.51 secs
  221.  
  222.     m = 1;
  223.     now = clock();
  224.     for (l = 0; l <= 10000l; l++) {
  225.         m *= 1.0001;        // Mult
  226.     }
  227.     elapsed = (clock()-now) / CLK_TCK;
  228.     d  = elapsed;           // 3.24 secs
  229.  
  230.     m = 1;
  231.     mm = pow(10, 6);
  232.     now = clock();
  233.     for (l = 0; l <= 10000l; l++) {
  234.         mm = m;
  235.         m /= 0.99001;       // Div
  236.         if (!m.OK()) {
  237.             m.FIX();        // won't fix overflows
  238.         }
  239.     }
  240.     elapsed = (clock()-now) / CLK_TCK;
  241.     d  = elapsed;           //  8.46 secs
  242.  
  243.     d  = m % m + 33;        //   33.00
  244.     m  = d;                 // $ 33.oo
  245.     mm = d / 330;           // $  0.10
  246.  
  247.     d = (10+mm)/m * m;      //   10.089...
  248.  
  249.     // Must use (double) type cast
  250.     printf ("Salary = %10.2f\n",
  251.            (double) ((10+mm)/m * m));
  252.     cout <<"Salary = "
  253.          << (double) ((10+mm)/m * m) << '\n';
  254.  
  255.  
  256.     // valid only if you define
  257.     // ostream& operator<< (ostream&, money&)
  258.     cout <<"Salary = "
  259.          << (10+mm)/m * m << '\n';
  260.  
  261. //  m = d / m;        // should not compile...
  262. //  m = m * m;        // won't compile: AMBIGUITY ERROR!!!
  263.  
  264.     #ifdef  RANGER
  265.         ranger();
  266.     #endif // RANGER
  267.  
  268. #endif    /* ] */
  269.     exit(0);
  270. }
  271.  
  272.  
  273. void ranger(void) {
  274. /*
  275.     Shows that indeed a double can hold up to
  276.     DBL_DIG digits of precission.
  277. */
  278.     // This should take forever to calculate...
  279.     char view[] = "0123456789/123456";
  280.     double s,t;
  281.     double tenpow,inc;
  282.     int    i;
  283.  
  284.     tenpow = pow(10, DBL_DIG); // 10^15
  285.     inc    = 100.0;            // pick yours
  286.  
  287.     s = floor(tenpow+inc); // 1,000,000,000,000,000 + inc
  288.     for (;;) {
  289.         t = s;
  290.         s += inc;
  291. //      i = (int) log10(t-tenpow);
  292.         if (s == t) {
  293.             i = (int) log10(t-tenpow);
  294.             cout << "BOOM t   = " << t      << '\n';
  295.             cout << "BOOM s   = " << s      << '\n';
  296.             cout << "BOOM inc = " << s      << '\n';
  297.             cout << "BOOM i   = " << i      << '\n';
  298.             view[i] = 0;
  299.             cout << "view     = " << view   << '\n';
  300.             return;
  301.         }
  302.     }
  303.  
  304.     return;
  305. } // ranger
  306.  
  307. #endif  /* TEST */  /* } */
  308.