test_bignum.cxx

InsightToolkit-1.4.0(有大量的优化算法程序)

  TEST("vnl_bignum(\"+Inf\")/(-1L)", vnl_bignum("+Inf")/(-1L), vnl_bignum("-Inf"));
  TEST("vnl_bignum(-1L)/0L", vnl_bignum(-1L)/0L, vnl_bignum("-Inf"));

  long i,j,k,l;
  long div_errors = 0;
  long mod_errors = 0;

  vcl_cout << " for (i = 0xffffff; i > 0; i /= 0x10) \n"
           << "   for (j = 0x7ffffff; j > 0; j /= 0x10) \n"
           << "     for (k = 1; k < 17; ++k) \n"
           << "       for (l = 1; l < 17; ++l) \n         ";
  for (i = 0xffffff; i > 0; i /= 0x10) {
    vcl_cout.put('.');
    vcl_cout.flush();
    for (j = 0x7ffffff; j > 0; j /= 0x10) {
      for (k = 1; k < 17; ++k) {
        for (l = 1; l < 17; ++l) {
          vnl_bignum b1(i+k);
          vnl_bignum b2(j+l);
          vnl_bignum b3(long((i+k)/(j+l)));
          if (b1/b2 != b3) {
            TEST("(vnl_bignum(i+k)/vnl_bignum(j+l)) == vnl_bignum(long((i+k)/(j+l)))", false, true);
#ifndef __alpha__ // On Alpha, compiler runs out of memory
            vcl_cout<<vcl_hex<< "i=0x"<<i<<", j=0x"<<j<<", k=0x"<<k<<", l="<<l
                    <<vcl_dec<<", b1="<<b1<<", b2="<<b2<<", b3="<<b3<<'\n';
#endif
            ++div_errors;
          }
          b3 = vnl_bignum(long((i+k)%(j+l)));
          if (b1%b2 != b3) {
            TEST("(vnl_bignum(i+k)%vnl_bignum(j+l)) == vnl_bignum(long((i+k)%(j+l)))", false, true);
#ifndef __alpha__ // On Alpha, compiler runs out of memory
            vcl_cout<<vcl_hex<< "i=0x"<<i<<", j=0x"<<j<<", k=0x"<<k<<", l="<<l
                    <<vcl_dec<<", b1="<<b1<<", b2="<<b2<<", b3="<<b3<<'\n';
#endif
            ++mod_errors;
          }
        }
      }
    }
  }

  vcl_cout << "\n";
  TEST("(vnl_bignum(i+k)/vnl_bignum(j+l)) == vnl_bignum(long((i+k)/(j+l)))",
       div_errors, 0);
  TEST("(vnl_bignum(i+k)%vnl_bignum(j+l)) == vnl_bignum(long((i+k)%(j+l)))",
       mod_errors, 0);

#ifdef INTERACTIVE
  char num[130], den[130];
  vnl_bignum b,r;

  while (1) {
    vcl_cout << "Enter next numerator:  ";
    vcl_cin >> num;
    vcl_cout << "Enter next denominator:  ";
    vcl_cin >> den;

    b = vnl_bignum(num)/vnl_bignum(den);
    r = vnl_bignum(num) % vnl_bignum(den);
    vcl_cout << "\nquotient  = " << b << "\n";
    vcl_cout <<   "            "; b.dump(); vcl_cout << "\n";
    vcl_cout << "\nremainder = " << r << "\n";
    vcl_cout <<   "            "; r.dump(); vcl_cout << "\n";
  }
#endif
}

static void run_multiplication_division_tests() {
  vcl_cout << "\nCheck example in book:\n";

  vnl_bignum b2 = "0xffffffff";                 // Create vnl_bignum object
  vnl_bignum b3 = "12345e30";                   // Create vnl_bignum object

  vcl_cout << "b2 = " << b2 << vcl_endl;
  vcl_cout << "b3 = " << b3 << vcl_endl;

  TEST("(b2*b3) / b3 = b2", ((b2*b3) / b3 == b2), 1);
  TEST("(b2*b3) / b2 = b3", ((b2*b3) / b2 == b3), 1);
  TEST("((b3/b2) * b2) + (b3%b2) = b3", (((b3/b2) * b2) + (b3%b2) == b3), 1);
}

static void run_addition_subtraction_tests() {
  vcl_cout << "\nStarting addition, subtraction tests:\n";

  long i,j;
  long add_errors = 0;
  long sub_errors = 0;
  vnl_bignum bi,bj,bij;

  vcl_cout << " for (i = 1; i < 0xfffffff;  i *= 3) \n";
  vcl_cout << "   for (j = 1; j < 0xfffffff; j *= 3) \n      ";

  {for (i = 1; i < 0xfffffff;  i *= 3) {
    vcl_cout.put('.');
    vcl_cout.flush();
    for (j = 1; j < 0xfffffff; j *= 3) {
      bi = i;
      bj = j;
      bij = vnl_bignum(i+j);
      if (bi + bj != bij) {
        TEST("bi + bj == vnl_bignum(i + j)", false, true);
        vcl_cout << "i = "<<i<<", j = "<<j<<"\n";
        ++add_errors;
      }
      bij = vnl_bignum(i-j);
      if (bi - bj != bij) {
        TEST("bi - bj == vnl_bignum(i - j)", false, true);
        vcl_cout << "i = "<<i<<", j = "<<j<<"\n";
        ++sub_errors;
      }
    }
  }}
  vcl_cout << "\n";
  TEST("bi + bj == vnl_bignum(i + j)", add_errors, 0);
  TEST("bi - bj == vnl_bignum(i - j)", sub_errors, 0);

  vnl_bignum b0(0L);
  vnl_bignum zillion("1000000000000000000");
  vnl_bignum b1000(1000L), b1000000(1000000L);
  vnl_bignum p_inf("+Inf"), m_inf("-Inf");

  TEST("-b0 == b0", -b0, b0);
  TEST("-p_inf == m_inf", -p_inf, m_inf);
  TEST("-m_inf == p_inf", -m_inf, p_inf);
  TEST("-b1000 == vnl_bignum(-1L)*b1000", -b1000, vnl_bignum(-1L)*b1000);
  TEST("-(-b1000000) == b1000000", -(-b1000000), b1000000);
  TEST("b0 + b1000 == b1000", b0 + b1000, b1000);
  TEST("b0 + b1000000 == b1000000", b0 + b1000000, b1000000);
  TEST("b1000 + b0 == b1000", b1000 + b0, b1000);
  TEST("b1000000 + b0 == b1000000", b1000000 + b0, b1000000);
  TEST("b0 + (-b1000) == -b1000", b0 + (-b1000), -b1000);
  TEST("-b1000 + b0 == -b1000", -b1000 + b0, -b1000);
  TEST("-b1000 + (-b1000) == (vnl_bignum(2L)*(-b1000))",
        -b1000 + (-b1000),   (vnl_bignum(2L)*(-b1000)));
  TEST("-b1000000 + (-b1000000) == (vnl_bignum(2L)*(-b1000000))",
        -b1000000 + (-b1000000), (vnl_bignum(2L)*(-b1000000)));
  TEST("b1000000 + (-b1000000) == b0", b1000000 + (-b1000000), b0);
  TEST("zillion + (-zillion) == b0", zillion + (-zillion), b0);
  TEST("zillion + b1000 == b1000000*b1000000*b1000000 + b1000",
        zillion + b1000,   b1000000*b1000000*b1000000 + b1000);
  TEST("zillion + p_inf == p_inf", zillion + p_inf, p_inf);
  TEST("zillion + m_inf == m_inf", zillion + m_inf, m_inf);
  TEST("p_inf + zillion == p_inf", p_inf + zillion, p_inf);
  TEST("m_inf + zillion == m_inf", m_inf + zillion, m_inf);

  TEST("b0 - b1000 == -b1000", b0 - b1000, -b1000);
  TEST("b0 - b1000000 == -b1000000", b0 -b1000000, -b1000000);
  TEST("b1000 - b0 == b1000", b1000 - b0, b1000);
  TEST("b1000000 - b0 == b1000000", b1000000 - b0, b1000000);
  TEST("b0 - (-b1000) == b1000", b0 - (-b1000), b1000);
  TEST("-b1000 - b0 == -b1000", -b1000 - b0, -b1000);
  TEST("-b1000 - (-b1000) == b0", -b1000 - (-b1000), b0);
  TEST("-b1000 - (-zillion) == zillion - b1000",
        -b1000 - (-zillion),   zillion - b1000);
  TEST("-b1000000 - (-b1000000) == b0", -b1000000 - (-b1000000), b0);
  TEST("-b1000000 - (b1000000) == -vnl_bignum(2L)*b1000000",
        -b1000000 - (b1000000),   -vnl_bignum(2L)*b1000000);
  TEST("b1000000 - (-b1000000) == vnl_bignum(2L)*b1000000",
        b1000000 - (-b1000000),   vnl_bignum(2L)*b1000000);
  TEST("zillion - (-zillion) == vnl_bignum(2L)*zillion",
        zillion - (-zillion),   vnl_bignum(2L)*zillion);
  TEST("zillion - b1000 == b1000000*b1000000*b1000000 - b1000",
        zillion - b1000,   b1000000*b1000000*b1000000 - b1000);
  TEST("-zillion - b1000 == -b1000000*b1000000*b1000000 - b1000",
        -zillion - b1000,   -b1000000*b1000000*b1000000 - b1000);
  TEST("zillion - p_inf == m_inf", zillion - p_inf, m_inf);
  TEST("zillion - m_inf == p_inf", zillion - m_inf, p_inf);
  TEST("p_inf - zillion == p_inf", p_inf - zillion, p_inf);
  TEST("m_inf - zillion == m_inf", m_inf - zillion, m_inf);

  // example in book
  vnl_bignum b2 = "0xffffffff";                 // Create vnl_bignum object
  vnl_bignum b3 = "12345e30";                   // Create vnl_bignum object
  TEST("(b2+b3) - b2 = b3", (b2+b3) - b2 == b3, 1);
  TEST("(b2+b3) - b3 = b2", (b2+b3) - b3 == b2, 1);
  b3.dump();
  TEST("b3.dump()", 1, 1);
}

static void run_multiplication_tests() {
  vcl_cout << "\nStarting multiplication tests:\n";

  vnl_bignum b0(0L), b1000(1000L), b1000000(1000000L),
  zillion("1000000000000000000");
  vnl_bignum p_inf("+Inf"), m_inf("-Inf");

  TEST("b0*b0 == b0", b0*b0, b0);
  TEST("b0*b1000 == b0", b0*b1000, b0);
  TEST("b1000*b0 == b0", b1000*b0, b0);
  TEST("b1000*b1000 == b1000000", b1000*b1000, b1000000);
  TEST("b1000*b1000000 == b1000000*b1000", b1000*b1000000, b1000000*b1000);
  TEST("-b1000000*b1000000*b1000000 == -zillion", -b1000000*b1000000*b1000000, -zillion);
  TEST("zillion*-b1000 == b1000*-zillion", zillion*-b1000, b1000*-zillion);
  TEST("p_inf*b1000 == p_inf", p_inf*b1000, p_inf);
  TEST("m_inf*b1000 == m_inf", m_inf*b1000, m_inf);
}

static void run_left_shift_tests()
{
  vnl_bignum b1(1L);
  vnl_bignum p_inf("+Inf"), m_inf("-Inf");

  // left shift
  TEST("int(b1) == 1",int(b1), 1);
  TEST("long(b1 << 1) == 2",long(b1 << 1), 2);
  TEST("long(b1 << 2) == 4",long(b1 << 2), 4);
  TEST("long(b1 << 3) == 8",long(b1 << 3), 8);
  TEST("long(b1 << 4) == 16",long(b1 << 4), 16);
  TEST("long(b1 << 5) == 32",long(b1 << 5), 32);
  TEST("long(b1 << 6) == 64",long(b1 << 6), 64);
  TEST("long(b1 << 7) == 128",long(b1 << 7), 128);
  TEST("long(b1 << 8) == 256",long(b1 << 8), 256);
  TEST("long(b1 << 9) == 512",long(b1 << 9), 512);
  TEST("long(b1 << 10) == 1024",long(b1 << 10), 1024);
  TEST("long(b1 << 11) == 2048",long(b1 << 11), 2048);
  TEST("long(b1 << 12) == 4096",long(b1 << 12), 4096);
  TEST("long(b1 << 13) == 8192",long(b1 << 13), 8192);
  TEST("long(b1 << 14) == 16384",long(b1 << 14), 16384);
  TEST("long(b1 << 15) == 32768",long(b1 << 15), 32768);
  TEST("long(b1 << 16) == 65536",long(b1 << 16), 65536);
  TEST("(b1 << 32) == vnl_bignum(\"4294967296\")",
       (b1 << 32), vnl_bignum("4294967296"));
  TEST("p_inf << 16 == p_inf",p_inf << 16, p_inf);

  TEST("long(-b1 << 1) == -2",long(-b1 << 1), -2);
  TEST("long(-b1 << 2) == -4",long(-b1 << 2), -4);
  TEST("long(-b1 << 3) == -8",long(-b1 << 3), -8);
  TEST("long(-b1 << 4) == -16",long(-b1 << 4), -16);
  TEST("long(-b1 << 5) == -32",long(-b1 << 5), -32);
  TEST("long(-b1 << 6) == -64",long(-b1 << 6), -64);
  TEST("long(-b1 << 7) == -128",long(-b1 << 7), -128);
  TEST("long(-b1 << 8) == -256",long(-b1 << 8), -256);
  TEST("long(-b1 << 9) == -512",long(-b1 << 9), -512);
  TEST("long(-b1 << 10) == -1024",long(-b1 << 10), -1024);
  TEST("long(-b1 << 11) == -2048",long(-b1 << 11), -2048);
  TEST("long(-b1 << 12) == -4096",long(-b1 << 12), -4096);
  TEST("long(-b1 << 13) == -8192",long(-b1 << 13), -8192);
  TEST("long(-b1 << 14) == -16384",long(-b1 << 14), -16384);
  TEST("long(-b1 << 15) == -32768",long(-b1 << 15), -32768);
  TEST("long(-b1 << 16) == -65536",long(-b1 << 16), -65536);
  TEST("(-b1 << 32) == vnl_bignum(\"-4294967296\")",
       (-b1 << 32), vnl_bignum("-4294967296"));
  TEST("m_inf << 16 == m_inf",m_inf << 16, m_inf);

  TEST("long(b1 << -16) == 0",long(b1 << -16), 0);
  TEST("long(-b1 << -16) == 0",long(-b1 << -16), 0);
}

static void run_right_shift_tests()
{
  vnl_bignum b2("4294967296");
  vnl_bignum p_inf("+Inf"), m_inf("-Inf");

  // right shift
  TEST("b2 == vnl_bignum(\"4294967296\")",b2, vnl_bignum("4294967296"));
  TEST("(b2 >> 1) == vnl_bignum(\"2147483648\")", (b2 >> 1), vnl_bignum("2147483648"));
  TEST("long(b2 >> 2) == 1073741824",long(b2 >> 2), 1073741824L);
  TEST("long(b2 >> 3) == 536870912",long(b2 >> 3), 536870912L);
  TEST("long(b2 >> 4) == 268435456",long(b2 >> 4), 268435456L);
  TEST("long(b2 >> 5) == 134217728",long(b2 >> 5), 134217728L);
  TEST("long(b2 >> 6) == 67108864",long(b2 >> 6), 67108864L);
  TEST("long(b2 >> 7) == 33554432",long(b2 >> 7), 33554432L);
  TEST("long(b2 >> 8) == 16777216",long(b2 >> 8), 16777216L);
  TEST("long(b2 >> 9) == 8388608",long(b2 >> 9), 8388608L);
  TEST("long(b2 >> 10) == 4194304",long(b2 >> 10), 4194304L);
  TEST("long(b2 >> 11) == 2097152",long(b2 >> 11), 2097152L);
  TEST("long(b2 >> 12) == 1048576",long(b2 >> 12), 1048576L);
  TEST("long(b2 >> 13) == 524288",long(b2 >> 13), 524288L);
  TEST("long(b2 >> 14) == 262144",long(b2 >> 14), 262144L);
  TEST("long(b2 >> 15) == 131072",long(b2 >> 15), 131072L);
  TEST("long(b2 >> 16) == 65536",long(b2 >> 16), 65536L);
  TEST("long(b2 >> 32) == 1",long(b2 >> 32), 1L);
  TEST("long(b2 >> 33) == 0",long(b2 >> 33), 0L);
  TEST("long(b2 >> 67) == 0",long(b2 >> 67), 0L);
  TEST("p_inf >> 16 == p_inf",p_inf >> 16, p_inf);

  TEST("(-b2 >> 1) == vnl_bignum(\"-2147483648\")", (-b2 >> 1), vnl_bignum("-2147483648"));
  TEST("long(-b2 >> 2) == -1073741824",long(-b2 >> 2), -1073741824L);
  TEST("long(-b2 >> 3) == -536870912",long(-b2 >> 3), -536870912L);
  TEST("long(-b2 >> 4) == -268435456",long(-b2 >> 4), -268435456L);
  TEST("long(-b2 >> 5) == -134217728",long(-b2 >> 5), -134217728L);
  TEST("long(-b2 >> 6) == -67108864",long(-b2 >> 6), -67108864L);
  TEST("long(-b2 >> 7) == -33554432",long(-b2 >> 7), -33554432L);
  TEST("long(-b2 >> 8) == -16777216",long(-b2 >> 8), -16777216L);
  TEST("long(-b2 >> 9) == -8388608",long(-b2 >> 9), -8388608L);
  TEST("long(-b2 >> 10) == -4194304",long(-b2 >> 10), -4194304L);
  TEST("long(-b2 >> 11) == -2097152",long(-b2 >> 11), -2097152L);
  TEST("long(-b2 >> 12) == -1048576",long(-b2 >> 12), -1048576L);
  TEST("long(-b2 >> 13) == -524288",long(-b2 >> 13), -524288L);
  TEST("long(-b2 >> 14) == -262144",long(-b2 >> 14), -262144L);
  TEST("long(-b2 >> 15) == -131072",long(-b2 >> 15), -131072L);
  TEST("long(-b2 >> 16) == -65536",long(-b2 >> 16), -65536L);
  TEST("long(-b2 >> 32) == -1",long(-b2 >> 32), -1);
  TEST("long(-b2 >> 33) == -0",long(-b2 >> 33), 0);
  TEST("long(-b2 >> 67) == -0",long(-b2 >> 67), 0);
  TEST("m_inf >> 16 == m_inf",m_inf >> 16, m_inf);
}

static void run_shift_tests() {
  vcl_cout << "\nStarting shift tests:\n";

  run_left_shift_tests();
  run_right_shift_tests();
#ifdef INTERACTIVE
  vnl_bignum b;
  char s[100];
  int sh;

  while (1) {
    vcl_cout << "Enter next vnl_bignum:  ";
    vcl_cin >> s;
    b = s;
    vcl_cout << "Enter shift amount: ";
    vcl_cin >> sh;
    vcl_cout << "Shift == " << sh << "\n";

    b = b << sh;
  }
#endif
}

void test_bignum() {
  run_constructor_tests();
  run_conversion_operator_tests();
  return;
  run_assignment_tests();
  run_addition_subtraction_tests();
  run_multiplication_tests();
  run_division_tests();
  run_multiplication_division_tests();
  run_shift_tests();
  run_logical_comparison_tests();
}

TESTMAIN(test_bignum);