home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / listings / v_10_04 / 1004063a < prev    next >
Text File  |  1991-09-18  |  8KB  |  306 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. int 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.     m  = d;           // $  25.84
  73.     m  = 7.009999999; // $   7.oo
  74.     m += 1;           // $   8.oo
  75.     m += 1.245000001; // $   9.24
  76.     m += 1L;          // $  10.24
  77.     m += 'a';         // $  'a'+10.24
  78.  
  79.     m  = -d;          // $ -25.84
  80.     m  = -7.00999999; // $ - 7.oo
  81.     m -= 1;           // $ - 8.oo
  82.     m -= 1.245000001; // $ - 9.24
  83.     m -= 1L;          // $ -10.24
  84.     m -= 'a';         // $ -'a'-10.24
  85.  
  86.     mm = 10;          // $  10.oo
  87.     m  = mm+4;        // $  14.oo
  88.     m  = mm+4.014999; // $  14.01
  89.     m  = 4.99+mm;     // $  14.99
  90.     m  = 4+mm;        // $  14.oo
  91.     m  = m+mm;        // $  24.oo
  92.     m += m;           // $  48.oo
  93.  
  94.     d  = mm+4;        //    14.oo
  95.     d  = mm+4.011;    //    14.0099999999999998
  96.     d  = 4.99+mm;     //    14.9900000000000002
  97.     d  = 4+mm;        //    14.oo
  98.  
  99.     mm = 10;          // $  10.oo
  100.     m  = mm*4;        // $  40.oo
  101.     m  = mm*4.0;      // $  40.oo
  102.     m  = 4*mm;        // $  40.oo
  103.     m  = 4.0*mm;      // $  40.oo
  104.  
  105.     mm = 10;          // $  10.oo
  106.     d  =  7.00001;    //     7.00000999999999962
  107.     m  = d*mm+d;      // $  77.oo
  108.     m  = (d*mm)+d;    // $  77.oo
  109.     m  = d+d*mm;      // $  77.oo
  110.     m  = d+(d*mm);    // $  77.oo
  111.  
  112.     m = 10;           // $  10.oo
  113.             mm = 77;  // $  77.oo
  114.     m = m % mm;       // $  10.oo
  115.     // $10 == 0L * $77 + [$10]
  116.  
  117.     m = 77;           // $  77.oo
  118.              mm = 10; // $  10.oo
  119.     m = m % mm;       // $   7.oo
  120.     // $77 == 7L * $10 + [$7]
  121.  
  122.     m++;              // $   8.oo
  123.     m--;              // $   7.oo
  124.  
  125.     m   = 11.75;                // $  11.75
  126.     m  +=  0.12;                // $  11.87
  127.     mm  = flatten(m,0.25,1);    // $  11.75
  128.  
  129.     m  += 0.01;                 // $  11.88
  130.     mm  = flatten(m,0.25,1);    // $  12.oo
  131.  
  132.     m   = 11.75;                // $  11.75
  133.     m  +=  0.12;                // $  11.87
  134.     mm  = flatten(m,0.25,0);    // $  11.75
  135.  
  136.     m  += 0.01;                 // $  11.88
  137.     mm  = flatten(m,0.25,0);    // $  11.75
  138.  
  139.     m  -= 5;
  140.     m  += 0.12;                 // $   7.oo
  141.     if (m == 0 || 0 == m) {     // nep
  142.         m += d;
  143.     }
  144.     else if (!(m == m)) {       // nep
  145.         m = m;
  146.     }
  147.     else if (m > m) {           // nep
  148.         m = m;
  149.     }
  150.     else if (m < m) {           // nep
  151.         m = m;
  152.     }
  153.     else if (m != m) {          // nep
  154.         m = m;
  155.     }
  156.     else if (m >= m) {          // yep
  157.         m *= 11;      // $  77.oo
  158.         m += 15;      // $  92.oo
  159.     }
  160.     l  = i = m;       //    92
  161.     m  = -m;          // $ -92.oo
  162.     mm = i*l;         // $   8,464.oo
  163.     m  = m % mm;      // $ -92.oo
  164.  
  165.     d  = 15.253;      //   15.253
  166.     m  = 15.25;       // $ 15.25
  167.  
  168.     if (d == m) {         // TRUE:  d becomes money(d)
  169.         l = 0;            // l = 0L
  170.     }
  171.     if (d == (double) m) { // FALSE: 15.253 != 15.25
  172.         l++;               // l == 0L
  173.     }
  174.  
  175.     // simulate a TAX calculation
  176.     m = 0.0;
  177.     for (i = 1; i <= 100; i++) {
  178.         d  = i*1.005;    // 0.05% tax
  179.         m += d;
  180.     }                    // $ 5,075.oo
  181.     mm = 100;            // $   100.oo
  182.     m /= (double) mm;    // $    50.75
  183.     m /=   3;            // $    16.91
  184.     m *=   3;            // $    50.73
  185.  
  186.     mm = mm/mm;          //       1.00
  187.     d  = m * (m / mm);   //    2573.5300000000002
  188.  
  189.     d  = 1.0/3.0 * m;    //      16.9100000000000001
  190.     mm = 1.0/3.0 * m;    // $    16.91
  191.  
  192.     mm = 3 * mm / (3 * mm);                  // $1.oo
  193.     mm = M_PI * mm / (M_PI * mm);            // $1.oo
  194.     mm = M_PI;                               // $3.14
  195.  
  196.     mm = mm/mm + 1 - (3 * mm / (3 * mm));    // $1.oo
  197.     m *= M_E * mm / (mm * M_E) - 1;          // $0.oo
  198.  
  199.     // m == 0.0 && mm == $1.oo
  200.     for (i = 1; i <= 100; i++) {
  201.         mm /= 3;          // $    0.33
  202.         m   = m+mm;       // Add a third
  203.         mm  = 1;
  204.     }                     // $    33.oo
  205.  
  206.     d  = m;               //      33.00
  207.     mm = m / 330;         // $     0.10
  208.  
  209.     clock_t now;
  210.     double  elapsed;
  211.  
  212.     // time statistics, on an 33MHz 386
  213.     m = 0;
  214.     now = clock();
  215.     for (l = 0; l <= 10000l; l++) {
  216.         m += 1.01;          // Add $1.01
  217.     }
  218.     elapsed = (clock()-now) / CLK_TCK;
  219.     d  = elapsed;           // 3.51 secs
  220.  
  221.     m = 1;
  222.     now = clock();
  223.     for (l = 0; l <= 10000l; l++) {
  224.         m *= 1.0001;        // Mult
  225.     }
  226.     elapsed = (clock()-now) / CLK_TCK;
  227.     d  = elapsed;           // 3.24 secs
  228.  
  229.     m = 1;
  230.     mm = pow(10, 6);
  231.     now = clock();
  232.     for (l = 0; l <= 10000l; l++) {
  233.         mm = m;
  234.         m /= 0.99001;       // Div
  235.         if (!m.OK()) {
  236.             m.FIX();        // won't fix overflows
  237.         }
  238.     }
  239.     elapsed = (clock()-now) / CLK_TCK;
  240.     d  = elapsed;           //  8.46 secs
  241.  
  242.     d  = m % m + 33;        //   33.00
  243.     m  = d;                 // $ 33.oo
  244.     mm = d / 330;           // $  0.10
  245.  
  246.     d = (10+mm)/m * m;      //   10.089...
  247.  
  248.     // Must use (double) type cast
  249.     printf ("Salary = %10.2f\n",
  250.            (double) ((10+mm)/m * m));
  251.     cout <<"Salary = "
  252.          << (double) ((10+mm)/m * m) << '\n';
  253.  
  254.  
  255.     // valid only if you define
  256.     // ostream& operator<< (ostream&, money&)
  257.     cout <<"Salary = "
  258.          << (10+mm)/m * m << '\n';
  259.  
  260.     m = d / m;        // should not compile...
  261. //  m = m * m;        // won't compile: AMBIGUITY ERROR!!!
  262.  
  263.     #ifdef  RANGER
  264.         ranger();
  265.     #endif // RANGER
  266.  
  267.     exit(0);
  268. }
  269.  
  270.  
  271. void ranger(void) {
  272. /*
  273.     Shows that indeed a double can hold up to
  274.     DBL_DIG digits of precission.
  275. */
  276.     // This should take forever to calculate...
  277.     char view[] = "0123456789/123456";
  278.     double s,t;
  279.     double tenpow,inc;
  280.     int    i;
  281.  
  282.     tenpow = pow(10, DBL_DIG); // 10^15
  283.     inc    = 100.0;            // pick yours
  284.  
  285.     s = floor(tenpow+inc); // 1,000,000,000,000,000 + inc
  286.     for (;;) {
  287.         t = s;
  288.         s += inc;
  289. //      i = (int) log10(t-tenpow);
  290.         if (s == t) {
  291.             i = (int) log10(t-tenpow);
  292.             cout << "BOOM t   = " << t      << '\n';
  293.             cout << "BOOM s   = " << s      << '\n';
  294.             cout << "BOOM inc = " << s      << '\n';
  295.             cout << "BOOM i   = " << i      << '\n';
  296.             view[i] = 0;
  297.             cout << "view     = " << view   << '\n';
  298.             return;
  299.         }
  300.     }
  301.  
  302.     return;
  303. } // ranger
  304.  
  305. #endif  /* TEST */  /* } */
  306.