void fname(Math) (void)
{
  REG CLASS x(DCAST .01);  
  REG CLASS p1;
  p1 += CLASS(DCAST .00000000001);
  assert(!p1.is_zero());
  assert (! approxEqual (p1, DCAST 0.0));

  p1 = CLASS(CLASS::Zero);
  assert(p1.is_zero());
  REG CLASS p2 = p1 + CLASS(DCAST .006) + CLASS(DCAST .08);
  double p2d = p2.ret_double();
  assert(approxEqual(p2, DCAST 0.086));
  for(;!p2.is_zero();p2 *= p2)  {}
  assert(approxEqual(p2,CLASS(CLASS::Zero)));

  p2 = CLASS(DCAST .4) * CLASS(DCAST.25);
  assert(approxEqual(p2, DCAST .1));

  p2 = DCAST .1;
  p2 = p2 / CLASS(DCAST.5);
  assert(approxEqual(p2,DCAST .2));
  p2 = DCAST 0.2;
#ifdef PROB  
  p2 = ~p2;
  assert(approxEqual(p2,DCAST 0.8));
#else
  p2 = DCAST .8;
#endif  
  
  REG CLASS p3(DCAST 0.5);
  (p2 -= p3);
  assert(approxEqual(p2,DCAST .3));
}
void fname(PrintSmall) (void)
{

  double oldp = 1;
  double pp = 0.1;
  REG CLASS p (DCAST oldp);
#ifdef PROB  
  cerr << "Epsilon for " CNAME " is "
       << CLASS::ret_epsilon() << " and its log is " 
       << log (CLASS::ret_epsilon()) << endl;
#endif  
  while (1)
  {
    p = DCAST pp;
    if (p.is_zero())
    {
      cerr << "The smallest convertable 1Ex " CNAME " is: "
	   << oldp << ", or exp(" << log(oldp) << ")\n";
      break;
    }
    oldp = pp;
    pp *= 0.1;
  }
  assert (! approxEqual (CLASS(DCAST oldp), CLASS(CLASS::Zero)));
    
  p = CLASS::One;
  int i = 1;
  int diff = 1;
  REG CLASS pmult(DCAST 0.1);
  while (diff > 0) {
    if (! (p*p).is_zero()) {
      p *= pmult;
      i += diff;
      diff += diff;
      pmult *= pmult;
    } else {
      diff /= 2;
      pmult = pow (pmult, 0.5);
    }
  }
  cerr << "Smallest 1Ex for " CNAME
       << " is: 1.0E"  << (double) -i << ", or exp(" << log(p) << ")\n";
}

void fname(Basics) (void)
{
  REG CLASS p1;
  assert(p1.is_zero());
  REG CLASS p2(DCAST 0.5);
  REG CLASS p3(CLASS::One);
#ifdef PROB  
  assert(p3.is_one());
#endif  
  REG CLASS p4(CLASS::Zero);
  assert(p4.is_zero());
  REG CLASS p5(p2);
  //CLASS p6(CLASS::from_log,-.75);
  //double p6log = p6.retLog();
  //assert(p6log == -0.75); // !!!

  assert(p1.ret_double() == 0.0);
  assert(p3.ret_double() == 1.0);
  assert(p4.ret_double() == 0.0);
  assert(p1 == p4);
  assert(p3 > p1);
  assert(p1 < p3);
  assert(p3 >= p1);
  assert(p1 <= p3);
  assert(p3 != p4);

#ifdef PROB  
  assert(p1 == min(p1,p3));
  assert(p3 == max(p1,p3));
#endif  
  p1 = DCAST .5;
  assert (approxEqual (p1, DCAST 0.5));
  p1 = DCAST .1;
  assert (approxEqual(p1, DCAST 0.1));
  assert (approxEqual(p1 + p1, DCAST 0.2));
  assert (approxEqual (p1 * p1, DCAST 0.01));
  assert (approxEqual (pow( CLASS(DCAST 0.008),1./3.), DCAST 0.2));
#ifdef REAL
  {REG CLASS p1 (0.2);
   REG CLASS p2 (0.1);
   assert (approxEqual(p2 - p1, -0.1));
   assert (approxEqual(p2 - (-p1), 0.3));
   assert (approxEqual(-p2 - p1, -0.3));
   assert (approxEqual(-p2 - (-p1), 0.1));

   assert (approxEqual(p2 + -p1, -0.1));
   assert (approxEqual(p2 + p1, 0.3));
   assert (approxEqual(-p2 + -p1, -0.3));
   assert (approxEqual(-p2 +p1, 0.1));
 }
#endif

#ifdef BASE  
  BASE b1;
  cout << BASENAME << " uninitialized values have log = " <<
  b1.ret_log() << endl;
#endif
}