home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / bcdclass.zip / BCDRUN.CPP < prev    next >
Text File  |  1995-09-24  |  18KB  |  323 lines
  1. // bcdrun.cpp  Test BCD Class
  2. #include <time.h>
  3. #include <fstream.h>
  4. #include "bcd.h"
  5. int main(void)
  6. {
  7.    struct tm *newtime;
  8.    time_t ltime; 
  9.    time(<ime);                 /* Get the time in seconds */
  10.    newtime = localtime(<ime);  /* Convert it to the structure tm */
  11.    char * st;            // gen purpose string for bcd's
  12.    st = new char[35];   // 32 digits + sign + decimal pt + '\0'
  13.  ofstream dout("bcdrun.log");
  14.    bcd numa("1234567890987654.123");  // fraction will be dropped
  15.    bcd numb(4321.6789);               // ditto - we are using integer rules
  16.    bcd numc(-24681357L);
  17.    bcd numd = numa + numb;
  18.    bcd e(0.0);
  19.    bcd f(0L);
  20.    bcd g(-0.0);
  21.    bcd h(-0L);
  22.    bcd w(1L);
  23.    bcd x(-1.0);
  24.    bcd y("-2.0");
  25.    bcd z("300.");
  26.    bcd aa("99999999999999999999999999999999");
  27.    bcd bb("1");
  28.    bcd cc("10000000000000000");
  29.    bcd dd(".00000000000000001");
  30.    bcd m1(12L);
  31.    bcd m2(2L);
  32.    bcd m3(123456789L);
  33.    bcd m4(4096L);
  34.    bcd m5(748345987654321.0);
  35.    bcd m6(288834570200345.0);
  36.    bcd m7("8599238847786248452455563809");
  37.    bcd d1("8765432109876");
  38.    bcd d2(24687L);
  39.    bcd d3(75237L);
  40.    bcd d4(45263L);
  41.    bcd d5 ("92732081006447");
  42.    bcd s1("1234567890987654");
  43.  
  44.    dout << "                 Regression Log for " << asctime(newtime) << endl;
  45.  
  46.    dout << "significant digits test: 1 = " << w.sigD() << ", 3 = " << z.sigD()
  47.         << ", 32 = " << aa.sigD() << ", 0 = " << dd.sigD() << "\n" << endl;
  48.  
  49.    int rc = numa.bcdToString(st); // convert numa to string no decimal point
  50.    dout << "bcd to string test = " << st << "\n"
  51.         << "          expected:  +1234567890987654" << endl;
  52.    rc = numa.bcdToString(st,1);   // numa to str with 1 psn to right of dec pt
  53.    dout << "bcd to string test = " << st << "\n"
  54.         << "          expected:  +123456789098765.4" << endl;
  55.    rc = numa.bcdToString(st,6);   // numa to str with 6 psns to rt of decimal pt
  56.    dout << "bcd to string test = " << st << "\n"
  57.         << "          expected:  +1234567890.987654" << "\n" << endl;
  58.  
  59.    rc = m3.bcdToString(st); // convert m3 to string no decimal point
  60.    dout << "bcd to string test  = " << st << "\n"
  61.         << "          expected:   +123456789" << endl;
  62.    rc = m3.bcdToString(st,1);   // m3 to str with 1 psn to right of dec pt
  63.    dout << "bcd to string test  = " << st << "\n"
  64.         << "          expected:   +12345678.9" << endl;
  65.    rc = m3.bcdToString(st,6);   // m3 to str with 6 psns to rt of decimal pt
  66.    dout << "bcd to string test  = " << st << "\n"
  67.         << "          expected:   +123.456789" << "\n" << endl;
  68.  
  69.    rc = h.bcdToString(st); // convert h to string no decimal point
  70.    dout << "bcd to string test  = " << st << "\n"
  71.         << "          expected:   +0" << endl;
  72.    rc = h.bcdToString(st,1);   // convert h to str with 1 psn to right of dec pt
  73.    dout << "bcd to string test  = " << st << "\n"
  74.         << "          expected:   +0.0" << endl;
  75.    rc = h.bcdToString(st,6);   // h to str with 6 psns to rt of decimal pt
  76.    dout << "bcd to string test  = " << st << "\n"
  77.         << "          expected:   +0.0" << "\n" << endl;
  78.  
  79.    rc = m2.bcdToString(st); // convert m2 to string no decimal point
  80.    dout << "bcd to string test  = " << st << "\n"
  81.         << "          expected:   +2" << endl;
  82.    rc = m2.bcdToString(st,1);   // m2 to str with 1 psn to right of dec pt
  83.    dout << "bcd to string test  = " << st << "\n"
  84.         << "          expected:   +0.2" << endl;
  85.    rc = m2.bcdToString(st,6);   // m2 to str with 6 psns to rt of decimal pt
  86.    dout << "bcd to string test  = " << st << "\n"
  87.         << "          expected:   +0.000002" << "\n" << endl;
  88.  
  89.    s1.shl(1);
  90.    dout << "shift test 1234567890987654 shifted left 1 = " << s1 
  91.         << "   expected                                = +00000000000000012345678909876540 cc: 0\n" << endl;
  92.    s1.shl(2);
  93.    dout << "shift test 1234567890987654 shifted left 2 = " << s1 
  94.         << "   expected                                = +00000000000001234567890987654000 cc: 0\n" << endl;
  95.    s1.shl(3);
  96.    dout << "shift test 1234567890987654 shifted left 3 = " << s1 
  97.         << "   expected                                = +00000000001234567890987654000000 cc: 0\n" << endl;
  98.    s1.shl(13);
  99.    dout << "shift test 1234567890987654 shfted left 13 = " << s1 
  100.         << "   expected                                = +00000000001234567890987654000000 cc: 16\n" << endl;
  101.    s1.shr(1);
  102.    dout << "shift test 1234567890987654 shifted rt 1 = " << s1 
  103.         << "   expected                              = +00000000000123456789098765400000 cc: 0\n" << endl;
  104.    s1.shr(2);
  105.    dout << "shift test 1234567890987654 shifted rt 2 = " << s1 
  106.         << "   expected                              = +00000000000001234567890987654000 cc: 0\n" << endl;
  107.    s1.shr(5);
  108.    dout << "shift test 1234567890987654 shifted rt 5 = " << s1 
  109.         << "   expected                              = +00000000000000000012345678909876 cc: 0\n" << endl;
  110.    s1.shrRnd(4);
  111.    dout << "shift test 12345678909876 sh rt 4 & rnd  = " << s1
  112.         << "   expected                              = +00000000000000000000001234567891 cc: 0\n" << endl;
  113.    s1.shrRnd(4);
  114.    dout << "shift test 12345678909876 sh rt 4 & rnd  = " << s1
  115.         << "   expected                              = +00000000000000000000000000123457 cc: 0\n" << endl;
  116.    s1.shrRnd(5);
  117.    dout << "shift test 12345678909876 sh rt 5 & rnd  = " << s1
  118.         << "   expected                              = +00000000000000000000000000000001 cc: 0\n" << endl;
  119.    s1.shl(31);
  120.    dout << "shift test 12345678909876 sh lt 31       = " << s1
  121.         << "   expected                              = +10000000000000000000000000000000 cc: 0\n" << endl;
  122.  
  123.    bcd s2("1234567890987654321");
  124.    s2.shrCpld(s1,6);               // odd shift even
  125.    dout << "coupled shift s2 > s1,   s1 = " << s1
  126.         << "                expected s1 = +00000000000000000000000000654321 cc: 0\n"
  127.         << "                         s2 = " << s2
  128.         << "                expected s2 = +00000000000000000001234567890987 cc: 0\n" << endl;
  129.    s2.shrCpld(s1,5);               // odd shift odd
  130.    dout << "coupled shift s2 > s1,   s1 = " << s1
  131.         << "                expected s1 = +00000000000000000000000000090987 cc: 0\n"
  132.         << "                         s2 = " << s2
  133.         << "                expected s2 = +00000000000000000000000012345678 cc: 0\n" << endl;
  134.    s2.shrCpld(s1,4);               // even shift even
  135.    dout << "coupled shift s2 > s1,   s1 = " << s1
  136.         << "                expected s1 = +00000000000000000000000000005678 cc: 0\n"
  137.         << "                         s2 = " << s2
  138.         << "                expected s2 = +00000000000000000000000000001234 cc: 0\n" << endl;
  139.    s2.shrCpld(s1,3);               // odd shift odd
  140.    dout << "coupled shift s2 > s1,   s1 = " << s1
  141.         << "                expected s1 = +00000000000000000000000000000234 cc: 0\n"
  142.         << "                         s2 = " << s2
  143.         << "                expected s2 = +00000000000000000000000000000001 cc: 0\n" << endl;
  144.  
  145.    dout << "logical test 1 < 2   = " << int(bb<m2) << "\n"
  146.         << "expected             = 1 \n" << endl;
  147.    dout << "logical test 1 > 2   = " << int(bb>m2) << "\n"
  148.         << "expected             = 0 \n" << endl;
  149.    dout << "logical test 1 = 2   = " << int(bb==m2) << "\n"
  150.         << "expected             = 0 \n" << endl;
  151.    dout << "logical test 2 < 1   = " << int(m2<bb) << "\n"
  152.         << "expected             = 0 \n" << endl;
  153.    dout << "logical test 2 > 1   = " << int(m2>bb) << "\n"
  154.         << "expected             = 1 \n" << endl;
  155.    dout << "logical test 2 = 1   = " << int(m2==bb) << "\n"
  156.         << "expected             = 0 \n" << endl;
  157.    dout << "logical test 1 < 12  = " << int(bb<m1) << "\n"
  158.         << "expected             = 1 \n" << endl;
  159.    dout << "logical test 1 > 12  = " << int(bb>m1) << "\n"
  160.         << "expected             = 0 \n" << endl;
  161.    dout << "logical test 1 = 12  = " << int(bb==m1) << "\n"
  162.         << "expected             = 0 \n" << endl;
  163.    dout << "logical test 12 < 1  = " << int(m1<bb) << "\n"
  164.         << "expected             = 0 \n" << endl;
  165.    dout << "logical test 12 > 1  = " << int(m1>bb) << "\n"
  166.         << "expected             = 1 \n" << endl;
  167.    dout << "logical test 12 = 1  = " << int(m1==bb) << "\n"
  168.         << "expected             = 0 \n" << endl;
  169.    dout << "logical test -1 < 2  = " << int(x<m2) << "\n"
  170.         << "expected             = 1 \n" << endl;
  171.    dout << "logical test -1 > 2  = " << int(x>m2) << "\n"
  172.         << "expected             = 0 \n" << endl;
  173.    dout << "logical test -1 = 2  = " << int(x==m2) << "\n"
  174.         << "expected             = 0 \n" << endl;
  175.    dout << "logical test 2 < -1  = " << int(m2<x) << "\n"
  176.         << "expected             = 0 \n" << endl;
  177.    dout << "logical test -1 != 2  = " << int(x!=m2) << "\n"
  178.         << "expected              = 1 \n" << endl;
  179.    dout << "logical test 2 != -1  = " << int(m2!=x) << "\n"
  180.         << "expected              = 1 \n" << endl;
  181.    dout << "logical test 2 != 2   = " << int(m2!=m2) << "\n"
  182.         << "expected              = 0 \n" << endl;
  183.    dout << "logical test 2 > -1  = " << int(m2>x) << "\n"
  184.         << "expected             = 1 \n" << endl;
  185.    dout << "logical test 2 = -1  = " << int(m2==x) << "\n"
  186.         << "expected             = 0 \n" << endl;
  187.    dout << "logical test d1 = d1 = " << int(d1==d1) << "\n"
  188.         << "expected             = 1 \n" << endl;
  189.    dout << "logical test 0 = -0  = " << int(f==h) << "\n"
  190.         << "expected             = 1 \n" << endl;
  191.    dout << "logical test -0 = 0  = " << int(h==f) << "\n"
  192.         << "expected             = 1 \n" << endl;
  193.    dout << "logical test 0 = 0   = " << int(f==f) << "\n"
  194.         << "expected             = 1 \n" << endl;
  195.    dout << "logical test -0 = -0 = " << int(h==h) << "\n"
  196.         << "expected             = 1 \n" << endl;
  197.    dout << "divide test 8765432109876/24687 = " << d1/d2
  198.         << "expected                        = +00000000000000000000000355062669 cc: 0\n" << endl;
  199.    dout << "divide tst 92732081006447/45263 = " << d5/d4
  200.         << "expected                        = +00000000000000000000002048739169 cc: 0\n" << endl;
  201.    dout << "divide test 8765432109876/75237 = " << d1/d3
  202.         << "expected                        = +00000000000000000000000116504274 cc: 0\n" << endl;
  203.    dout << "divide test 1/24687             = " << bb/d2
  204.         << "expected                        = +00000000000000000000000000000000 cc: 0\n" << endl;
  205.    dout << "   test 10000000000000000/24687 = " << cc/d2
  206.         << "expected                        = +00000000000000000000405071495118 cc: 0\n" << endl;
  207.    dout << "   test 10000000000000000/3     = " << cc/3L
  208.         << "expected                        = +00000000000000003333333333333333 cc: 0\n" << endl;
  209.    dout << "   test 10000000000000000/6     = " << cc/6L
  210.         << "expected                        = +00000000000000001666666666666666 cc: 0\n" << endl;
  211.    dout << "   test 10000000000000000/7     = " << cc/7L
  212.         << "expected                        = +00000000000000001428571428571428 cc: 0\n" << endl;
  213.    dout << " div test 22000000000000000/7   = " << (cc*22L)/7L
  214.         << "expected                        = +00000000000000031428571428571428 cc: 0\n" << endl;
  215.    dout << "modulus test 24687%1000         = " << d2%1000L
  216.         << "expected                        = +00000000000000000000000000000687 cc: 0\n" << endl;
  217.    dout << "divide by zero test 75237/0     = " << d3/0L
  218.         << "expected                        = +00000000000000000000000000075237 cc: 16\n" << endl;
  219.    dout << "divide d1/d1 test               = " << d1/d1
  220.         << "expected                        = +00000000000000000000000000000001 cc: 0\n" << endl;
  221.    dout << "re-subtract test: 12345 - 12346 = " << bcd(12345L) - 12346L
  222.         << "expected                        = -00000000000000000000000000000001 cc: 0\n"
  223.         << " reverse opnds:   12346 - 12345 = " << bcd(12346L) - 12345L
  224.         << "expected                        = +00000000000000000000000000000001 cc: 0\n" << endl;
  225.    dout << "8599238847786248452455563809*45263       = " << m7 * d4
  226.         << "                               expected:   +00008599238847786248452455563809 cc: 15\n" << endl;
  227.    dout << "748345987654321 x 288834570200345        = " << m5 * m6
  228.         << "                               expected:   +00216148191705288491573574940745 cc: 0\n" << endl;
  229.    dout << "748345987654321 x 288834570200345 x 10   = " << m5 * m6 * 10.0
  230.         << "                               expected:   +02161481917052884915735749407450 cc: 0\n" << endl;
  231.    dout << "748345987654321 x 288834570200345 x 100  = " << m5 * m6 * 100.0
  232.         << "                               expected:   +21614819170528849157357494074500 cc: 0\n" << endl;
  233.    dout << "748345987654321 x 288834570200345 x 1000 = " << m5 * m6 * 1000.0
  234.         << "                               expected:   +00216148191705288491573574940745 cc: 16\n" << endl;
  235.    dout << "123456789 x 123456789 x 123456789        = " << m3 * m3 * m3
  236.         << "                               expected:   +00000001881676371789154860897069 cc: 0\n" << endl;
  237.    dout << "123456789 x 123456789 x 123456789 x 123456789 = " << m3 * m3 * m3 * m3
  238.         << "                                    expected:   +00000001881676371789154860897069 cc: 16\n" << endl;
  239.    dout << "                                        2 x 2 = " << m2*m2
  240.         << "                                    expected:   +00000000000000000000000000000004 cc: 0\n" << endl;
  241.    dout << "                                       2 x 12 = " << m2*m1
  242.         << "                                    expected:   +00000000000000000000000000000024 cc: 0\n" << endl;
  243.    dout << "                                2 x 123456789 = " << m2 * m3
  244.         << "                                    expected:   +00000000000000000000000246913578 cc: 0\n" << endl;
  245.    dout << "                                123456789 x 2 = " << m3 * m2
  246.         << "                                    expected:   +00000000000000000000000246913578 cc: 0\n" << endl;
  247.    dout << " 4096 x 2 = " << m4 * m2
  248.         << "expected:   +00000000000000000000000000008192 cc: 0\n" << endl;
  249.    dout << " 2 x 4096 = " << m2 * m4
  250.         << "expected:   +00000000000000000000000000008192 cc: 0\n" << endl;
  251.    dout << " 2 x 12 x 4096 = " << m2 * m1 * m4
  252.         << "expected:        +00000000000000000000000000098304 cc: 0\n" << endl;
  253.    dout << "    aa = " << aa
  254.         << "    bb = " << bb
  255.         << " aa-bb = " << aa-bb
  256.         << "expected:+99999999999999999999999999999998 cc: 0\n"
  257.         << " aa+bb = " << aa+bb 
  258.         << "expected:+00000000000000000000000000000000 cc: 1\n" << endl;
  259.    dout << "     e = " << e
  260.         << "     f = " << f
  261.         << " e + f = " << e+f
  262.         << "expected:+00000000000000000000000000000000 cc: 0\n" 
  263.         << " e - f = " << e-f 
  264.         << "expected:+00000000000000000000000000000000 cc: 0\n" << endl;
  265.    dout << "     g = " << g
  266.         << "     h = " << h
  267.         << " g + h = " << g+h
  268.         << "expected:+00000000000000000000000000000000 cc: 0\n"
  269.         << " g - h = " << g-h 
  270.         << "expected:+00000000000000000000000000000000 cc: 0\n" << endl;
  271.    dout << "     w = " << w
  272.         << "     x = " << x
  273.         << " w + x = " << w+x
  274.         << "expected:+00000000000000000000000000000000 cc: 0\n"
  275.         << " w - x = " << w-x 
  276.         << "expected:+00000000000000000000000000000002 cc: 0\n" << endl;
  277.    dout << "     y = " << y
  278.         << "     z = " << z
  279.         << " y + z = " << y+z
  280.         << "expected:+00000000000000000000000000000298 cc: 0\n"
  281.         << " y - z = " << y-z 
  282.         << "expected:-00000000000000000000000000000302 cc: 0\n" << endl;
  283.    dout << "numa =      " << numa 
  284.         << "numb =      " << numb
  285.         << "numa+numb = " << numd
  286.         << "expected:   +00000000000000001234567890991975 cc: 0\n"
  287.         << "numb+numa = " << numb+numa 
  288.         << "expected:   +00000000000000001234567890991975 cc: 0\n" << endl;
  289.    dout << "numa =      " << numa 
  290.         << "numc =      " << numc
  291.         << "numa+numc = " << numa+numc 
  292.         << "expected:   +00000000000000001234567866306297 cc: 0\n"
  293.         << "numc+numa = " << numc+numa
  294.         << "expected:   +00000000000000001234567866306297 cc: 0\n" << endl;
  295.    dout << "numb =      " << numb
  296.         << "numc =      " << numc
  297.         << "numb+numc = " << numb+numc 
  298.         << "expected:   -00000000000000000000000024677036 cc: 0\n"
  299.         << "numc+numb = " << numc+numb 
  300.         << "expected:   -00000000000000000000000024677036 cc: 0\n" << endl;
  301.    dout << "numa =      " << numa 
  302.         << "numb =      " << numb
  303.         << "numa-numb = " << numa-numb 
  304.         << "expected:   +00000000000000001234567890983333 cc: 0\n" 
  305.         << "numb-numa = " << numb-numa 
  306.         << "expected:   -00000000000000001234567890983333 cc: 0\n" << endl;
  307.    dout << "numa =      " << numa 
  308.         << "numc =      " << numc
  309.         << "numa-numc = " << numa-numc 
  310.         << "expected:   +00000000000000001234567915669011 cc: 0\n"
  311.         << "numc-numa = " << numc-numa 
  312.         << "expected:   -00000000000000001234567915669011 cc: 0\n" << endl;
  313.    dout << "numb =      " << numb
  314.         << "numc =      " << numc
  315.         << "numb-numc = " << numb-numc 
  316.         << "expected:   +00000000000000000000000024685678 cc: 0\n"
  317.         << "numc-numb = " << numc-numb
  318.         << "expected:   -00000000000000000000000024685678 cc: 0\n" << endl;
  319.    dout.close();
  320.    delete st;
  321.    return 0;
  322. }
  323.