test_bignum.cxx

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

//:
// \file
// converted from COOL/test/test_BigNum.C by Peter Vanroose, 25 April 2002.

#include <vcl_iostream.h>
#include <vcl_limits.h> // for vcl_numeric_limits<double>::infinity()
#ifndef __alpha__ // On Alpha, compiler runs out of memory when including these
# include <vcl_sstream.h>
# include <vcl_iomanip.h>
#endif
#include <vnl/vnl_bignum.h>
#include <vnl/vnl_bignum_traits.h>
#include <vnl/vnl_numeric_traits.h> // for vnl_numeric_traits<double>::maxval

#include <testlib/testlib_test.h>

static void run_constructor_tests()
{
  vcl_cout << "\nbignum constructor tests:\n";

  vcl_cout << "long constructor:\n";
  {vnl_bignum b(0L); TEST("vnl_bignum b(0L);", b, 0L);}
  {vnl_bignum b(1L); TEST("vnl_bignum b(1L);", b, 1L);}
  {vnl_bignum b(-1L); TEST("vnl_bignum b(-1L);", b, -1L);}
  {vnl_bignum b(0x7fffL); TEST("vnl_bignum b(0x7fffL);", b, 0x7fffL);}
  {vnl_bignum b(-0x7fffL); TEST("vnl_bignum b(-0x7fffL);", b, -0x7fffL);}
  {vnl_bignum b(0x7fffffffL); TEST("vnl_bignum b(0x7fffffffL);", b, 0x7fffffffL);}
  {vnl_bignum b(-0x7fffffffL); TEST("vnl_bignum b(-0x7fffffffL);", b, -0x7fffffffL);}
  {vnl_bignum b(0xf00000L); TEST("vnl_bignum b(0xf00000L);", b, 0xf00000);}

  vcl_cout << "double constructor:\n";
  {vnl_bignum b(0.0); TEST("vnl_bignum b(0.0);", (double)b, 0.0);}
  {vnl_bignum b(1.0); TEST("vnl_bignum b(1.0);", (double)b, 1.0);}
  {vnl_bignum b(-1.0); TEST("vnl_bignum b(-1.0);", (double)b, -1.0);}
  {vnl_bignum b(vnl_numeric_traits<double>::maxval);
   TEST("vnl_bignum b(vnl_numeric_traits<double>::maxval);", (double)b, vnl_numeric_traits<double>::maxval);}
  {vnl_bignum b(-vnl_numeric_traits<double>::maxval);
   TEST("vnl_bignum b(-vnl_numeric_traits<double>::maxval);", (double)b, -vnl_numeric_traits<double>::maxval);}
  {vnl_bignum b(1234567.0); TEST("vnl_bignum b(1234567.0);", (double)b, 1234567.0);}
  {vnl_bignum b(-1234567.0); TEST("vnl_bignum b(-1234567.0);", (double)b, -1234567.0);}
  {vnl_bignum b(1234567e3); TEST("vnl_bignum b(1234567e3);", (double)b, 1234567e3);}
  {vnl_bignum b(-1234567e3); TEST("vnl_bignum b(-1234567e3);", (double)b, -1234567e3);}
  {vnl_bignum b(double(0xf00000)); TEST("vnl_bignum b(double(0xf00000));", b, 0xf00000);}

  vcl_cout << "long double constructor:\n";
  {vnl_bignum b(0.0L); TEST("vnl_bignum b(0.0L);", (long double)b, 0.0L);}
  {vnl_bignum b(1.0L); TEST("vnl_bignum b(1.0L);", (long double)b, 1.0L);}
  {vnl_bignum b(-1.0L); TEST("vnl_bignum b(-1.0L);", (long double)b, -1.0L);}
  {vnl_bignum b(1234567.0L); TEST("vnl_bignum b(1234567.0L);", (long double)b, 1234567.0L);}
  {vnl_bignum b(-1234567.0L); TEST("vnl_bignum b(-1234567.0L);", (long double)b, -1234567.0L);}
  {vnl_bignum b(1234567e3L); TEST("vnl_bignum b(1234567e3L);", (long double)b, 1234567e3L);}
  {vnl_bignum b(-1234567e3L); TEST("vnl_bignum b(-1234567e3L);", (long double)b, -1234567e3L);}
  {vnl_bignum b((long double)(0xf00000)); TEST("vnl_bignum b((long double)(0xf00000));", (long double)b, (long double)0xf00000);}

  vcl_cout << "char* constructor:\n";
  {vnl_bignum b("-1"); TEST("vnl_bignum b(\"-1\");", b, -1L);}
  {vnl_bignum b("+1"); TEST("vnl_bignum b(\"+1\");", b, 1L);}
  {vnl_bignum b("1"); TEST("vnl_bignum b(\"1\");", b, 1L);}
  {vnl_bignum b("123"); TEST("vnl_bignum b(\"123\");", b, 123L);}
  {vnl_bignum b("123e5"); TEST("vnl_bignum b(\"123e5\");", b, 12300000L);}
  {vnl_bignum b("123e+4"); TEST("vnl_bignum b(\"123e+4\");", b, 1230000L);}
  {vnl_bignum b("123e12"); TEST("vnl_bignum b(\"123e12\");", (double)b, 123e12);}
#ifndef __alpha__ // On Alpha, compiler runs out of memory when using <sstream>
  {vnl_bignum b("-1e120"); vcl_stringstream s; s << b; vcl_cout << b << '\n';
   // verify that b outputs as  "-1000...00" (120 zeros)
   bool t = s.str()[0] == '-' && s.str()[1] == '1';
   for (int i=0; i<120; ++i) t = t && s.str()[i+2] == '0';
   TEST("vnl_bignum b(\"-1e120\") outputs first 122 digits as \"-10000...00\"", t, true);
   // This isolates a problem that used to be part of the previous test.
   // I don't think this test failure is a bug in vnl.
   // vnl_bignum seems to populate the stringstream with 122 chars,
   // but the stringstream then reports its size as something else
   // on some systems. - FWW
   TEST("vnl_bignum b(\"-1e120\") outputs a length 122 string", s.str().length(), 122);
   vcl_cout << "length of string: " << s.str().length() << vcl_endl;
  }
#else
  {vnl_bignum b("-1e120"); vcl_cout << b << '\n';}
#endif
  {vnl_bignum b("0x0"); TEST("vnl_bignum b(\"0x0\");", b, 0x0);}
  {vnl_bignum b("0x9"); TEST("vnl_bignum b(\"0x9\");", b, 0x9);}
  {vnl_bignum b("0xa"); TEST("vnl_bignum b(\"0xa\");", b, 0xa);}
  {vnl_bignum b("0xf"); TEST("vnl_bignum b(\"0xf\");", b, 0xf);}
  {vnl_bignum b("0xA"); TEST("vnl_bignum b(\"0xA\");", b, 0xa);}
  {vnl_bignum b("0xF"); TEST("vnl_bignum b(\"0xF\");", b, 0xf);}
  {vnl_bignum b("0x1aF"); TEST("vnl_bignum b(\"0x1aF\");", b, 0x1af);}
  {vnl_bignum b("0"); TEST("vnl_bignum b(\"0\");", b, 0);}
  {vnl_bignum b("00"); TEST("vnl_bignum b(\"00\");", b, 0);}
  {vnl_bignum b("012334567"); TEST("vnl_bignum b(\"012334567\");", b, 012334567);}
  {vnl_bignum b("9"); TEST("vnl_bignum b(\"9\");", b, 9);}
  {vnl_bignum b(" 9"); TEST("vnl_bignum b(\" 9\");", b, 9);}
  // infinity:
  {vnl_bignum b("+Inf"); TEST("vnl_bignum b(\"+Inf\");", b.is_plus_infinity(), true);}
  {vnl_bignum b("Infinity"); TEST("vnl_bignum b(\"Infinity\");", b.is_plus_infinity(), true);}
  {vnl_bignum b("-Infin"); TEST("vnl_bignum b(\"-Infin\");", b.is_minus_infinity(), true);}

#ifndef __alpha__ // On Alpha, compiler runs out of memory when using <sstream>
  vcl_cout << "reading from istream:\n";
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "+1"; is >> b; TEST("\"+1\" >> b;", b, 1L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "-1"; is >> b; TEST("\"-1\" >> b;", b, -1L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "123"; is >> b; TEST("\"123\" >> b;", b, 123L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "123e5"; is >> b; TEST("\"123e5\" >> b;", b, 12300000L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "123e+4"; is >> b; TEST("\"123e+4\" >> b;", b, 1230000L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0x0"; is >> b; TEST("\"0x0\" >> b;", b, 0x0);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0x9"; is >> b; TEST("\"0x9\" >> b;", b, 0x9);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0xa"; is >> b; TEST("\"0xa\" >> b;", b, 0xa);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0xf"; is >> b; TEST("\"0xf\" >> b;", b, 0xf);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0xA"; is >> b; TEST("\"0xA\" >> b;", b, 0xa);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0xF"; is >> b; TEST("\"0xF\" >> b;", b, 0xf);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0x1aF"; is >> b; TEST("\"0x1aF\" >> b;", b, 0x1af);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "0"; is >> b; TEST("\"0\" >> b;", b, 0L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "00"; is >> b; TEST("\"00\" >> b;", b, 0L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "012334567"; is >> b; TEST("\"012334567\" >> b;", b, 012334567);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << "9"; is >> b; TEST("\"9\" >> b;", b, 9L);}
  {vcl_stringstream is(vcl_ios_in | vcl_ios_out); vnl_bignum b;
   is << " 9"; is >> b; TEST("\" 9\" >> b;", b, 9L);}
#endif

  vcl_cout << "vnl_bignum& constructor:\n";
  {vnl_bignum b50(vnl_bignum(0L));
  TEST("vnl_bignum b50(vnl_bignum(0L));", (long)b50, 0L);}

  {vnl_bignum b51(vnl_bignum(100L));
  TEST("vnl_bignum b51(vnl_bignum(100L));", (long)b51, 100L);}
}

static void run_conversion_operator_tests()
{
  vcl_cout << "\nConversion operator tests:\n";

  vcl_cout << "short conversion operator:\n";
  TEST("short(vnl_bignum(0L)) == 0", short(vnl_bignum(0L)), 0);
  TEST("short(vnl_bignum(0x7fffL)) == 0x7fff", short(vnl_bignum(0x7fffL)), 0x7fff);
  TEST("short(vnl_bignum(-0x7fffL)) == -0x7fff", short(vnl_bignum(-0x7fffL)), -0x7fff);
  TEST("short(vnl_bignum(-0x8000L)) == short(-0x8000)", short(vnl_bignum(-0x8000L)), short(-0x8000));

  vcl_cout << "int conversion operator:\n";
  TEST("int(vnl_bignum(0L)) == 0", int(vnl_bignum(0L)), 0);
  TEST("int(vnl_bignum(0x7fffffffL)) == 0x7fffffff", int(vnl_bignum(0x7fffffffL)), 0x7fffffff);
  TEST("int(vnl_bignum(-0x7fffffffL)) == -0x7fffffff", int(vnl_bignum(-0x7fffffffL)), -0x7fffffff);

  vcl_cout << "long conversion operator:\n";
  vnl_bignum b(0x7fffffffL);
  ++b;
  // Two casts are used here instead of a direct cast to unsigned long
  // because vnl_bignum does not implement an overload of "cast to
  // unsigned long".
  TEST("vnl_bignum b(0x7fffffffL); ++b; (unsigned long)long(b) == 0x80000000UL", (unsigned long)long(b), 0x80000000UL);
  --b;
  TEST("vnl_bignum b(0x80000000UL); --b; long(b) == 0x7fffffffL", long(b), 0x7fffffffL);

  // Use -0x7fffffffL-0x1L below instead of -0x80000000L because the
  // latter is parsed like -(0x80000000L) and 0x80000000L is promoted
  // to unsigned long because it is too big to be a signed long.
  ++b; b = -b;
  TEST("vnl_bignum b(0x7fffffffL); ++b; b=-b; long(b) == -0x7fffffffL-0x1L", long(b), -0x7fffffffL-0x1L);

  vcl_cout << "float conversion operator:\n";
  TEST("float(vnl_bignum(0.0)) == 0.0", (float) vnl_bignum(0.0), 0.0);
  TEST("float(vnl_bignum(99999.0)) == 99999.0",
       ((float) vnl_bignum(99999.0)), 99999.0);
  TEST("float(vnl_bignum(vnl_numeric_traits<float>::maxval)) == vnl_numeric_traits<float>::maxval",
       (vnl_numeric_traits<float>::maxval), (float) vnl_bignum(vnl_numeric_traits<float>::maxval));
  TEST("float(vnl_bignum(-vnl_numeric_traits<float>::maxval)) == -vnl_numeric_traits<float>::maxval",
       (-vnl_numeric_traits<float>::maxval), float(vnl_bignum(-vnl_numeric_traits<float>::maxval)));
  TEST("float(vnl_bignum(\"+Inf\")) == +Inf", (float) vnl_bignum("+Inf"), vcl_numeric_limits<float>::infinity());

  b = vnl_numeric_traits<double>::maxval;
  ++b;
  TEST("vnl_numeric_traits<double>::maxval + 1 is valid", b.is_infinity(), false);

  vcl_cout << "double conversion operator:\n";
  TEST("double(vnl_bignum(0.0)) == 0.0", (double) vnl_bignum(0.0), 0.0);
  TEST("double(vnl_bignum(99999.0)) == 99999.0",
       (double) vnl_bignum(99999.0), 99999.0);
  TEST("double(vnl_bignum(1e300)) == 1e300",
       double(vnl_bignum(1e300)), 1e300);
  TEST("double(vnl_bignum(-1e300)) == -1e300",
       double(vnl_bignum(-1e300)), -1e300);
  TEST("double(vnl_bignum(vnl_numeric_traits<float>::maxval)) == vnl_numeric_traits<float>::maxval",
       (vnl_numeric_traits<float>::maxval), (double) vnl_bignum(vnl_numeric_traits<float>::maxval));
  TEST("double(vnl_bignum(-vnl_numeric_traits<float>::maxval)) == -vnl_numeric_traits<float>::maxval",
       (-vnl_numeric_traits<float>::maxval), double(vnl_bignum(-vnl_numeric_traits<float>::maxval)));
  TEST("double(vnl_bignum(vnl_numeric_traits<double>::maxval)) == vnl_numeric_traits<double>::maxval",
       (double) vnl_bignum(vnl_numeric_traits<double>::maxval), vnl_numeric_traits<double>::maxval);
  TEST("double(vnl_bignum(-vnl_numeric_traits<double>::maxval)) == -vnl_numeric_traits<double>::maxval",
       (double) vnl_bignum(-vnl_numeric_traits<double>::maxval), -vnl_numeric_traits<double>::maxval);
  TEST("double(vnl_bignum(\"+Inf\")) == +Inf", (double) vnl_bignum("+Inf"), vcl_numeric_limits<double>::infinity());

  // Test for bug in bignum::dtobignum()
  // it wasn't resetting the value at the start.
  const vnl_bignum e(1000);
  vnl_bignum d(20);
  vnl_bignum_from_string(d, "1000");
  TEST("vnl_bignum_from_string", e, d);
}

static void run_assignment_tests()
{
  vcl_cout << "\nStarting assignment tests:\n";
  vnl_bignum b1;

  TEST_RUN ("vnl_bignum b1; b1 = 0xffff;", b1 = 0xffffL, long(b1), 0xffffL);

  // double assignment operator
  TEST_RUN ("double(b1) == -1.23e6", b1 = -1.23e6, double(b1), -1.23e6);

  // long assignment operator
  TEST_RUN ("long(b1) = -0x7fffffff", b1 = -0x7fffffffL, long(b1), -0x7fffffff);

  // char * assignment operator
  TEST_RUN ("long(b1) = 0x1fffffL", b1 = "0x1fffff", long(b1), 0x1fffffL);


  // vnl_bignum& assignment operator
  b1 = "0";
  vnl_bignum b5(0x1ffffL);
  TEST_RUN ("b1 = b5", b1 = b5, b1, b5);
}

static void run_logical_comparison_tests()
{
  vcl_cout << "\nStarting logical comparison tests:\n";
  vnl_bignum b0(0L);
  vnl_bignum b1(1L);
  vnl_bignum b2(0x7fffL);
  vnl_bignum b3(-0x7fffL);
  vnl_bignum p_inf("+Inf");
  vnl_bignum m_inf("-Inf");

  TEST("b0 == b0", b0 == b0, true);
  TEST("b0 == b1", b0 == b1, false);
  TEST("b0 == b2", b0 == b2, false);
  TEST("b0 == b3", b0 == b3, false);
  TEST("b1 == b1", b1 == b1, true);
  TEST("b1 == b2", b1 == b2, false);
  TEST("b1 == b3", b1 == b3, false);