* gcc.c-torture/execute/20020720-1.x: Don't XFAIL for mips.

[gcc.git] / contrib / paranoia.cc

/*	A C version of Kahan's Floating Point Test "Paranoia"

Thos Sumner, UCSF, Feb. 1985
David Gay, BTL, Jan. 1986

This is a rewrite from the Pascal version by

B. A. Wichmann, 18 Jan. 1985

(and does NOT exhibit good C programming style).

Adjusted to use Standard C headers 19 Jan. 1992 (dmg);

(C) Apr 19 1983 in BASIC version by:
Professor W. M. Kahan,
567 Evans Hall
Electrical Engineering & Computer Science Dept.
University of California
Berkeley, California 94720
USA

converted to Pascal by:
B. A. Wichmann
National Physical Laboratory
Teddington Middx
TW11 OLW
UK

converted to C by:

David M. Gay		and	Thos Sumner
AT&T Bell Labs			Computer Center, Rm. U-76
600 Mountain Avenue		University of California
Murray Hill, NJ 07974		San Francisco, CA 94143
USA				USA

with simultaneous corrections to the Pascal source (reflected
in the Pascal source available over netlib).
[A couple of bug fixes from dgh = sun!dhough incorporated 31 July 1986.]

Reports of results on various systems from all the versions
of Paranoia are being collected by Richard Karpinski at the
same address as Thos Sumner.  This includes sample outputs,
bug reports, and criticisms.

You may copy this program freely if you acknowledge its source.
Comments on the Pascal version to NPL, please.

The following is from the introductory commentary from Wichmann's work:

The BASIC program of Kahan is written in Microsoft BASIC using many
facilities which have no exact analogy in Pascal.  The Pascal
version below cannot therefore be exactly the same.  Rather than be
a minimal transcription of the BASIC program, the Pascal coding
follows the conventional style of block-structured languages.  Hence
the Pascal version could be useful in producing versions in other
structured languages.

Rather than use identifiers of minimal length (which therefore have
little mnemonic significance), the Pascal version uses meaningful
identifiers as follows [Note: A few changes have been made for C]:


BASIC   C               BASIC   C               BASIC   C

A                       J                       S    StickyBit
A1   AInverse           J0   NoErrors           T
B    Radix                    [Failure]         T0   Underflow
B1   BInverse           J1   NoErrors           T2   ThirtyTwo
B2   RadixD2                  [SeriousDefect]   T5   OneAndHalf
B9   BMinusU2           J2   NoErrors           T7   TwentySeven
C                             [Defect]          T8   TwoForty
C1   CInverse           J3   NoErrors           U    OneUlp
D                             [Flaw]            U0   UnderflowThreshold
D4   FourD              K    PageNo             U1
E0                      L    Milestone          U2
E1                      M                       V
E2   Exp2               N                       V0
E3                      N1                      V8
E5   MinSqEr            O    Zero               V9
E6   SqEr               O1   One                W
E7   MaxSqEr            O2   Two                X
E8                      O3   Three              X1
E9                      O4   Four               X8
F1   MinusOne           O5   Five               X9   Random1
F2   Half               O8   Eight              Y
F3   Third              O9   Nine               Y1
F6                      P    Precision          Y2
F9                      Q                       Y9   Random2
G1   GMult              Q8                      Z
G2   GDiv               Q9                      Z0   PseudoZero
G3   GAddSub            R                       Z1
H                       R1   RMult              Z2
H1   HInverse           R2   RDiv               Z9
I                       R3   RAddSub
IO   NoTrials           R4   RSqrt
I3   IEEE               R9   Random9

SqRWrng

All the variables in BASIC are true variables and in consequence,
the program is more difficult to follow since the "constants" must
be determined (the glossary is very helpful).  The Pascal version
uses Real constants, but checks are added to ensure that the values
are correctly converted by the compiler.

The major textual change to the Pascal version apart from the
identifiersis that named procedures are used, inserting parameters
wherehelpful.  New procedures are also introduced.  The
correspondence is as follows:


BASIC       Pascal
lines

90- 140   Pause
170- 250   Instructions
380- 460   Heading
480- 670   Characteristics
690- 870   History
2940-2950   Random
3710-3740   NewD
4040-4080   DoesYequalX
4090-4110   PrintIfNPositive
4640-4850   TestPartialUnderflow

*/

  /* This version of paranoia has been modified to work with GCC's internal
     software floating point emulation library, as a sanity check of same.

     I'm doing this in C++ so that I can do operator overloading and not
     have to modify so damned much of the existing code.  */

  extern "C" {
#include <stdio.h>
#include <stddef.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <float.h>

    /* This part is made all the more awful because many gcc headers are
       not prepared at all to be parsed as C++.  The biggest stickler
       here is const structure members.  So we include exactly the pieces
       that we need.  */

#define GTY(x)

#include "ansidecl.h"
#include "auto-host.h"
#include "hwint.h"

#undef EXTRA_MODES_FILE

    struct rtx_def;
    typedef struct rtx_def *rtx;
    struct rtvec_def;
    typedef struct rtvec_def *rtvec;
    union tree_node;
    typedef union tree_node *tree;

#define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
    enum tree_code {
#include "tree.def"
      LAST_AND_UNUSED_TREE_CODE
    };
#undef DEFTREECODE

#include "real.h"
  }

/* We never produce signals from the library.  Thus setjmp need do nothing.  */
#undef setjmp
#define setjmp(x)  (0)

static bool verbose = false;
static int verbose_index = 0;

/* ====================================================================== */
/* The implementation of the abstract floating point class based on gcc's
   real.c.  I.e. the object of this excersize.  Templated so that we can
   all fp sizes.  */

template<int SIZE, enum machine_mode MODE>
class real_c_float
{
 private:
  long image[SIZE / 32];

  void from_long(long);
  void from_str(const char *);
  void binop(int code, const real_c_float&);
  void unop(int code);
  bool cmp(int code, const real_c_float&) const;

 public:
  real_c_float()
    { }
  real_c_float(long l)
    { from_long(l); }
  real_c_float(const char *s)
    { from_str(s); }
  real_c_float(const real_c_float &b)
    { memcpy(image, b.image, sizeof(image)); }

  const real_c_float& operator= (long l)
    { from_long(l); return *this; }
  const real_c_float& operator= (const char *s)
    { from_str(s); return *this; }
  const real_c_float& operator= (const real_c_float &b)
    { memcpy(image, b.image, sizeof(image)); return *this; }

  const real_c_float& operator+= (const real_c_float &b)
    { binop(PLUS_EXPR, b); return *this; }
  const real_c_float& operator-= (const real_c_float &b)
    { binop(MINUS_EXPR, b); return *this; }
  const real_c_float& operator*= (const real_c_float &b)
    { binop(MULT_EXPR, b); return *this; }
  const real_c_float& operator/= (const real_c_float &b)
    { binop(RDIV_EXPR, b); return *this; }

  real_c_float operator- () const
    { real_c_float r(*this); r.unop(NEGATE_EXPR); return r; }
  real_c_float abs () const
    { real_c_float r(*this); r.unop(ABS_EXPR); return r; }

  bool operator <  (const real_c_float &b) const { return cmp(LT_EXPR, b); }
  bool operator <= (const real_c_float &b) const { return cmp(LE_EXPR, b); }
  bool operator == (const real_c_float &b) const { return cmp(EQ_EXPR, b); }
  bool operator != (const real_c_float &b) const { return cmp(NE_EXPR, b); }
  bool operator >= (const real_c_float &b) const { return cmp(GE_EXPR, b); }
  bool operator >  (const real_c_float &b) const { return cmp(GT_EXPR, b); }

  const char * str () const;
  const char * hex () const;
  long integer () const;
  int exp () const;
  void ldexp (int);
};

template<int SIZE, enum machine_mode MODE>
void
real_c_float<SIZE, MODE>::from_long (long l)
{
  REAL_VALUE_TYPE f;

  real_from_integer (&f, MODE, l, l < 0 ? -1 : 0, 0);
  real_to_target (image, &f, MODE);
}

template<int SIZE, enum machine_mode MODE>
void
real_c_float<SIZE, MODE>::from_str (const char *s)
{
  REAL_VALUE_TYPE f;
  char *p = s;

  if (*p == '-' || *p == '+')
    p++;
  if (strcasecmp(p, "inf") == 0)
    {
      real_inf (&f);
      if (*s == '-')
        real_arithmetic (&f, NEGATE_EXPR, &f, NULL);
    }
  else if (strcasecmp(p, "nan") == 0)
    real_nan (&f, "", 1, MODE);
  else
    real_from_string (&f, s);

  real_to_target (image, &f, MODE);
}

template<int SIZE, enum machine_mode MODE>
void
real_c_float<SIZE, MODE>::binop (int code, const real_c_float &b)
{
  REAL_VALUE_TYPE ai, bi, ri;

  real_from_target (&ai, image, MODE);
  real_from_target (&bi, b.image, MODE);
  real_arithmetic (&ri, code, &ai, &bi);
  real_to_target (image, &ri, MODE);

  if (verbose)
    {
      char ab[64], bb[64], rb[64];
      const int digits = int(SIZE / 4);
      char symbol_for_code;

      real_from_target (&ri, image, MODE);
      real_to_hexadecimal (ab, &ai, digits);
      real_to_hexadecimal (bb, &bi, digits);
      real_to_hexadecimal (rb, &ri, digits);

      switch (code)
	{
	case PLUS_EXPR:
	  symbol_for_code = '+';
	  break;
	case MINUS_EXPR:
	  symbol_for_code = '-';
	  break;
	case MULT_EXPR:
	  symbol_for_code = '*';
	  break;
	case RDIV_EXPR:
	  symbol_for_code = '/';
	  break;
	default:
	  abort ();
	}

      fprintf (stderr, "%6d: %s %c %s = %s\n", verbose_index++,
	       ab, symbol_for_code, bb, rb);
    }
}

template<int SIZE, enum machine_mode MODE>
void
real_c_float<SIZE, MODE>::unop (int code)
{
  REAL_VALUE_TYPE ai, ri;

  real_from_target (&ai, image, MODE);
  real_arithmetic (&ri, code, &ai, NULL);
  real_to_target (image, &ri, MODE);

  if (verbose)
    {
      char ab[64], rb[64];
      const int digits = int(SIZE / 4);
      const char *symbol_for_code;

      real_from_target (&ri, image, MODE);
      real_to_hexadecimal (ab, &ai, digits);
      real_to_hexadecimal (rb, &ri, digits);

      switch (code)
	{
	case NEGATE_EXPR:
	  symbol_for_code = "-";
	  break;
	case ABS_EXPR:
	  symbol_for_code = "abs ";
	  break;
	default:
	  abort ();
	}

      fprintf (stderr, "%6d: %s%s = %s\n", verbose_index++,
	       symbol_for_code, ab, rb);
    }
}

template<int SIZE, enum machine_mode MODE>
bool
real_c_float<SIZE, MODE>::cmp (int code, const real_c_float &b) const
{
  REAL_VALUE_TYPE ai, bi;
  bool ret;

  real_from_target (&ai, image, MODE);
  real_from_target (&bi, b.image, MODE);
  ret = real_compare (code, &ai, &bi);

  if (verbose)
    {
      char ab[64], bb[64];
      const int digits = int(SIZE / 4);
      const char *symbol_for_code;

      real_to_hexadecimal (ab, &ai, digits);
      real_to_hexadecimal (bb, &bi, digits);

      switch (code)
	{
	case LT_EXPR:
	  symbol_for_code = "<";
	  break;
	case LE_EXPR:
	  symbol_for_code = "<=";
	  break;
	case EQ_EXPR:
	  symbol_for_code = "==";
	  break;
	case NE_EXPR:
	  symbol_for_code = "!=";
	  break;
	case GE_EXPR:
	  symbol_for_code = ">=";
	  break;
	case GT_EXPR:
	  symbol_for_code = ">";
	  break;
	default:
	  abort ();
	}

      fprintf (stderr, "%6d: %s %s %s = %s\n", verbose_index++,
	       ab, symbol_for_code, bb, (ret ? "true" : "false"));
    }

  return ret;
}

template<int SIZE, enum machine_mode MODE>
const char *
real_c_float<SIZE, MODE>::str() const
{
  REAL_VALUE_TYPE f;
  const int digits = int(SIZE * .30102999566398119521 + 1);

  real_from_target (&f, image, MODE);
  char *buf = new char[digits + 10];
  real_to_decimal (buf, &f, digits);

  return buf;
}

template<int SIZE, enum machine_mode MODE>
const char *
real_c_float<SIZE, MODE>::hex() const
{
  REAL_VALUE_TYPE f;
  const int digits = int(SIZE / 4);

  real_from_target (&f, image, MODE);
  char *buf = new char[digits + 10];
  real_to_hexadecimal (buf, &f, digits);

  return buf;
}

template<int SIZE, enum machine_mode MODE>
long
real_c_float<SIZE, MODE>::integer() const
{
  REAL_VALUE_TYPE f;
  real_from_target (&f, image, MODE);
  return real_to_integer (&f);
}

template<int SIZE, enum machine_mode MODE>
int
real_c_float<SIZE, MODE>::exp() const
{
  REAL_VALUE_TYPE f;
  real_from_target (&f, image, MODE);
  return real_exponent (&f);
}

template<int SIZE, enum machine_mode MODE>
void
real_c_float<SIZE, MODE>::ldexp (int exp)
{
  REAL_VALUE_TYPE ai;

  real_from_target (&ai, image, MODE);
  real_ldexp (&ai, &ai, exp);
  real_to_target (image, &ai, MODE);
}

/* ====================================================================== */
/* An implementation of the abstract floating point class that uses native
   arithmetic.  Exists for reference and debugging.  */

template<typename T>
class native_float
{
 private:
  // Force intermediate results back to memory.
  volatile T image;

  static T from_str (const char *);
  static T do_abs (T);
  static T verbose_binop (T, char, T, T);
  static T verbose_unop (const char *, T, T);
  static bool verbose_cmp (T, const char *, T, bool);

 public:
  native_float()
    { }
  native_float(long l)
    { image = l; }
  native_float(const char *s)
    { image = from_str(s); }
  native_float(const native_float &b)
    { image = b.image; }

  const native_float& operator= (long l)
    { image = l; return *this; }
  const native_float& operator= (const char *s)
    { image = from_str(s); return *this; }
  const native_float& operator= (const native_float &b)
    { image = b.image; return *this; }

  const native_float& operator+= (const native_float &b)
    {
      image = verbose_binop(image, '+', b.image, image + b.image);
      return *this;
    }
  const native_float& operator-= (const native_float &b)
    {
      image = verbose_binop(image, '-', b.image, image - b.image);
      return *this;
    }
  const native_float& operator*= (const native_float &b)
    {
      image = verbose_binop(image, '*', b.image, image * b.image);
      return *this;
    }
  const native_float& operator/= (const native_float &b)
    {
      image = verbose_binop(image, '/', b.image, image / b.image);
      return *this;
    }

  native_float operator- () const
    {
      native_float r;
      r.image = verbose_unop("-", image, -image);
      return r;
    }
  native_float abs () const
    {
      native_float r;
      r.image = verbose_unop("abs ", image, do_abs(image));
      return r;
    }

  bool operator <  (const native_float &b) const
    { return verbose_cmp(image, "<", b.image, image <  b.image); }
  bool operator <= (const native_float &b) const
    { return verbose_cmp(image, "<=", b.image, image <= b.image); }
  bool operator == (const native_float &b) const
    { return verbose_cmp(image, "==", b.image, image == b.image); }
  bool operator != (const native_float &b) const
    { return verbose_cmp(image, "!=", b.image, image != b.image); }
  bool operator >= (const native_float &b) const
    { return verbose_cmp(image, ">=", b.image, image >= b.image); }
  bool operator >  (const native_float &b) const
    { return verbose_cmp(image, ">", b.image, image > b.image); }

  const char * str () const;
  const char * hex () const;
  long integer () const
    { return long(image); }
  int exp () const;
  void ldexp (int);
};

template<typename T>
inline T
native_float<T>::from_str (const char *s)
{
  return strtold (s, NULL);
}

template<>
inline float
native_float<float>::from_str (const char *s)
{
  return strtof (s, NULL);
}

template<>
inline double
native_float<double>::from_str (const char *s)
{
  return strtod (s, NULL);
}

template<typename T>
inline T
native_float<T>::do_abs (T image)
{
  return fabsl (image);
}

template<>
inline float
native_float<float>::do_abs (float image)
{
  return fabsf (image);
}

template<>
inline double
native_float<double>::do_abs (double image)
{
  return fabs (image);
}

template<typename T>
T
native_float<T>::verbose_binop (T a, char symbol, T b, T r)
{
  if (verbose)
    {
      const int digits = int(sizeof(T) * CHAR_BIT / 4) - 1;
#ifdef NO_LONG_DOUBLE
      fprintf (stderr, "%6d: %.*a %c %.*a = %.*a\n", verbose_index++,
	       digits, (double)a, symbol,
	       digits, (double)b, digits, (double)r);
#else
      fprintf (stderr, "%6d: %.*La %c %.*La = %.*La\n", verbose_index++,
	       digits, (long double)a, symbol,
	       digits, (long double)b, digits, (long double)r);
#endif
    }
  return r;
}

template<typename T>
T
native_float<T>::verbose_unop (const char *symbol, T a, T r)
{
  if (verbose)
    {
      const int digits = int(sizeof(T) * CHAR_BIT / 4) - 1;
#ifdef NO_LONG_DOUBLE
      fprintf (stderr, "%6d: %s%.*a = %.*a\n", verbose_index++,
	       symbol, digits, (double)a, digits, (double)r);
#else
      fprintf (stderr, "%6d: %s%.*La = %.*La\n", verbose_index++,
	       symbol, digits, (long double)a, digits, (long double)r);
#endif
    }
  return r;
}

template<typename T>
bool
native_float<T>::verbose_cmp (T a, const char *symbol, T b, bool r)
{
  if (verbose)
    {
      const int digits = int(sizeof(T) * CHAR_BIT / 4) - 1;
#ifndef NO_LONG_DOUBLE
      fprintf (stderr, "%6d: %.*a %s %.*a = %s\n", verbose_index++,
	       digits, (double)a, symbol,
	       digits, (double)b, (r ? "true" : "false"));
#else
      fprintf (stderr, "%6d: %.*La %s %.*La = %s\n", verbose_index++,
	       digits, (long double)a, symbol,
	       digits, (long double)b, (r ? "true" : "false"));
#endif
    }
  return r;
}

template<typename T>
const char *
native_float<T>::str() const
{
  char *buf = new char[50];
  const int digits = int(sizeof(T) * CHAR_BIT * .30102999566398119521 + 1);
#ifndef NO_LONG_DOUBLE
  sprintf (buf, "%.*e", digits - 1, (double) image);
#else
  sprintf (buf, "%.*Le", digits - 1, (long double) image);
#endif
  return buf;
}

template<typename T>
const char *
native_float<T>::hex() const
{
  char *buf = new char[50];
  const int digits = int(sizeof(T) * CHAR_BIT / 4);
#ifndef NO_LONG_DOUBLE
  sprintf (buf, "%.*a", digits - 1, (double) image);
#else
  sprintf (buf, "%.*La", digits - 1, (long double) image);
#endif
  return buf;
}

template<typename T>
int
native_float<T>::exp() const
{
  int e;
  frexp (image, &e);
  return e;
}

template<typename T>
void
native_float<T>::ldexp (int exp)
{
  image = ldexpl (image, exp);
}

template<>
void
native_float<float>::ldexp (int exp)
{
  image = ldexpf (image, exp);
}

template<>
void
native_float<double>::ldexp (int exp)
{
  image = ::ldexp (image, exp);
}

/* ====================================================================== */
/* Some libm routines that Paranoia expects to be available.  */

template<typename FLOAT>
inline FLOAT
FABS (const FLOAT &f)
{
  return f.abs();
}

template<typename FLOAT, typename RHS>
inline FLOAT
operator+ (const FLOAT &a, const RHS &b)
{
  return FLOAT(a) += FLOAT(b);
}

template<typename FLOAT, typename RHS>
inline FLOAT
operator- (const FLOAT &a, const RHS &b)
{
  return FLOAT(a) -= FLOAT(b);
}

template<typename FLOAT, typename RHS>
inline FLOAT
operator* (const FLOAT &a, const RHS &b)
{
  return FLOAT(a) *= FLOAT(b);
}

template<typename FLOAT, typename RHS>
inline FLOAT
operator/ (const FLOAT &a, const RHS &b)
{
  return FLOAT(a) /= FLOAT(b);
}

template<typename FLOAT>
FLOAT
FLOOR (const FLOAT &f)
{
  /* ??? This is only correct when F is representable as an integer.  */
  long i = f.integer();
  FLOAT r;

  r = i;
  if (i < 0 && f != r)
    r = i - 1;

  return r;
}

template<typename FLOAT>
FLOAT
SQRT (const FLOAT &f)
{
#if 0
  FLOAT zero = long(0);
  FLOAT two = 2;
  FLOAT one = 1;
  FLOAT diff, diff2;
  FLOAT z, t;

  if (f == zero)
    return zero;
  if (f < zero)
    return zero / zero;
  if (f == one)
    return f;

  z = f;
  z.ldexp (-f.exp() / 2);

  diff2 = FABS (z * z - f);
  if (diff2 > zero)
    while (1)
      {
	t = (f / (two * z)) + (z / two);
	diff = FABS (t * t - f);
	if (diff >= diff2)
	  break;
	z = t;
	diff2 = diff;
      }

  return z;
#elif defined(NO_LONG_DOUBLE)
  double d;
  char buf[64];

  d = strtod (f.hex(), NULL);
  d = sqrt (d);
  sprintf(buf, "%.35a", d);

  return FLOAT(buf);
#else
  long double ld;
  char buf[64];

  ld = strtold (f.hex(), NULL);
  ld = sqrtl (ld);
  sprintf(buf, "%.35La", ld);

  return FLOAT(buf);
#endif
}

template<typename FLOAT>
FLOAT
LOG (FLOAT x)
{
#if 0
  FLOAT zero = long(0);
  FLOAT one = 1;

  if (x <= zero)
    return zero / zero;
  if (x == one)
    return zero;

  int exp = x.exp() - 1;
  x.ldexp(-exp);

  FLOAT xm1 = x - one;
  FLOAT y = xm1;
  long n = 2;

  FLOAT sum = xm1;
  while (1)
    {
      y *= xm1;
      FLOAT term = y / FLOAT (n);
      FLOAT next = sum + term;
      if (next == sum)
	break;
      sum = next;
      if (++n == 1000)
	break;
    }

  if (exp)
    sum += FLOAT (exp) * FLOAT(".69314718055994530941");

  return sum;
#elif defined (NO_LONG_DOUBLE)
  double d;
  char buf[64];

  d = strtod (x.hex(), NULL);
  d = log (d);
  sprintf(buf, "%.35a", d);

  return FLOAT(buf);
#else
  long double ld;
  char buf[64];

  ld = strtold (x.hex(), NULL);
  ld = logl (ld);
  sprintf(buf, "%.35La", ld);

  return FLOAT(buf);
#endif
}

template<typename FLOAT>
FLOAT
EXP (const FLOAT &x)
{
  /* Cheat.  */
#ifdef NO_LONG_DOUBLE
  double d;
  char buf[64];

  d = strtod (x.hex(), NULL);
  d = exp (d);
  sprintf(buf, "%.35a", d);

  return FLOAT(buf);
#else
  long double ld;
  char buf[64];

  ld = strtold (x.hex(), NULL);
  ld = expl (ld);
  sprintf(buf, "%.35La", ld);

  return FLOAT(buf);
#endif
}

template<typename FLOAT>
FLOAT
POW (const FLOAT &base, const FLOAT &exp)
{
  /* Cheat.  */
#ifdef NO_LONG_DOUBLE
  double d1, d2;
  char buf[64];

  d1 = strtod (base.hex(), NULL);
  d2 = strtod (exp.hex(), NULL);
  d1 = pow (d1, d2);
  sprintf(buf, "%.35a", d1);

  return FLOAT(buf);
#else
  long double ld1, ld2;
  char buf[64];

  ld1 = strtold (base.hex(), NULL);
  ld2 = strtold (exp.hex(), NULL);
  ld1 = powl (ld1, ld2);
  sprintf(buf, "%.35La", ld1);

  return FLOAT(buf);
#endif
}

/* ====================================================================== */
/* Real Paranoia begins again here.  We wrap the thing in a template so
   that we can instantiate it for each floating point type we care for.  */

int NoTrials = 20;		/*Number of tests for commutativity. */
bool do_pause = false;

enum Guard { No, Yes };
enum Rounding { Other, Rounded, Chopped };
enum Class { Failure, Serious, Defect, Flaw };

template<typename FLOAT>
struct Paranoia
{
  FLOAT Radix, BInvrse, RadixD2, BMinusU2;

  /* Small floating point constants.  */
  FLOAT Zero;
  FLOAT Half;
  FLOAT One;
  FLOAT Two;
  FLOAT Three;
  FLOAT Four;
  FLOAT Five;
  FLOAT Eight;
  FLOAT Nine;
  FLOAT TwentySeven;
  FLOAT ThirtyTwo;
  FLOAT TwoForty;
  FLOAT MinusOne;
  FLOAT OneAndHalf;

  /* Declarations of Variables.  */
  int Indx;
  char ch[8];
  FLOAT AInvrse, A1;
  FLOAT C, CInvrse;
  FLOAT D, FourD;
  FLOAT E0, E1, Exp2, E3, MinSqEr;
  FLOAT SqEr, MaxSqEr, E9;
  FLOAT Third;
  FLOAT F6, F9;
  FLOAT H, HInvrse;
  int I;
  FLOAT StickyBit, J;
  FLOAT MyZero;
  FLOAT Precision;
  FLOAT Q, Q9;
  FLOAT R, Random9;
  FLOAT T, Underflow, S;
  FLOAT OneUlp, UfThold, U1, U2;
  FLOAT V, V0, V9;
  FLOAT W;
  FLOAT X, X1, X2, X8, Random1;
  FLOAT Y, Y1, Y2, Random2;
  FLOAT Z, PseudoZero, Z1, Z2, Z9;
  int ErrCnt[4];
  int Milestone;
  int PageNo;
  int M, N, N1;
  Guard GMult, GDiv, GAddSub;
  Rounding RMult, RDiv, RAddSub, RSqrt;
  int Break, Done, NotMonot, Monot, Anomaly, IEEE, SqRWrng, UfNGrad;

  /* Computed constants. */
  /*U1  gap below 1.0, i.e, 1.0-U1 is next number below 1.0 */
  /*U2  gap above 1.0, i.e, 1.0+U2 is next number above 1.0 */

  int main ();

  FLOAT Sign (FLOAT);
  FLOAT Random ();
  void Pause ();
  void BadCond (int, const char *);
  void SqXMinX (int);
  void TstCond (int, int, const char *);
  void notify (const char *);
  void IsYeqX ();
  void NewD ();
  void PrintIfNPositive ();
  void SR3750 ();
  void TstPtUf ();

  // Pretend we're bss.
  Paranoia() { memset(this, 0, sizeof (*this)); }
};

template<typename FLOAT>
int
Paranoia<FLOAT>::main()
{
  /* First two assignments use integer right-hand sides. */
  Zero = long(0);
  One = long(1);
  Two = long(2);
  Three = long(3);
  Four = long(4);
  Five = long(5);
  Eight = long(8);
  Nine = long(9);
  TwentySeven = long(27);
  ThirtyTwo = long(32);
  TwoForty = long(240);
  MinusOne = long(-1);
  Half = "0x1p-1";
  OneAndHalf = "0x3p-1";
  ErrCnt[Failure] = 0;
  ErrCnt[Serious] = 0;
  ErrCnt[Defect] = 0;
  ErrCnt[Flaw] = 0;
  PageNo = 1;
	/*=============================================*/
  Milestone = 7;
	/*=============================================*/
  printf ("Program is now RUNNING tests on small integers:\n");

  TstCond (Failure, (Zero + Zero == Zero), "0+0 != 0");
  TstCond (Failure, (One - One == Zero), "1-1 != 0");
  TstCond (Failure, (One > Zero), "1 <= 0");
  TstCond (Failure, (One + One == Two), "1+1 != 2");

  Z = -Zero;
  if (Z != Zero)
    {
      ErrCnt[Failure] = ErrCnt[Failure] + 1;
      printf ("Comparison alleges that -0.0 is Non-zero!\n");
      U2 = "0.001";
      Radix = 1;
      TstPtUf ();
    }

  TstCond (Failure, (Three == Two + One), "3 != 2+1");
  TstCond (Failure, (Four == Three + One), "4 != 3+1");
  TstCond (Failure, (Four + Two * (-Two) == Zero), "4 + 2*(-2) != 0");
  TstCond (Failure, (Four - Three - One == Zero), "4-3-1 != 0");

  TstCond (Failure, (MinusOne == (Zero - One)), "-1 != 0-1");
  TstCond (Failure, (MinusOne + One == Zero), "-1+1 != 0");
  TstCond (Failure, (One + MinusOne == Zero), "1+(-1) != 0");
  TstCond (Failure, (MinusOne + FABS (One) == Zero), "-1+abs(1) != 0");
  TstCond (Failure, (MinusOne + MinusOne * MinusOne == Zero),
	   "-1+(-1)*(-1) != 0");

  TstCond (Failure, Half + MinusOne + Half == Zero, "1/2 + (-1) + 1/2 != 0");

	/*=============================================*/
  Milestone = 10;
	/*=============================================*/

  TstCond (Failure, (Nine == Three * Three), "9 != 3*3");
  TstCond (Failure, (TwentySeven == Nine * Three), "27 != 9*3");
  TstCond (Failure, (Eight == Four + Four), "8 != 4+4");
  TstCond (Failure, (ThirtyTwo == Eight * Four), "32 != 8*4");
  TstCond (Failure, (ThirtyTwo - TwentySeven - Four - One == Zero),
	   "32-27-4-1 != 0");

  TstCond (Failure, Five == Four + One, "5 != 4+1");
  TstCond (Failure, TwoForty == Four * Five * Three * Four, "240 != 4*5*3*4");
  TstCond (Failure, TwoForty / Three - Four * Four * Five == Zero,
	   "240/3 - 4*4*5 != 0");
  TstCond (Failure, TwoForty / Four - Five * Three * Four == Zero,
	   "240/4 - 5*3*4 != 0");
  TstCond (Failure, TwoForty / Five - Four * Three * Four == Zero,
	   "240/5 - 4*3*4 != 0");

  if (ErrCnt[Failure] == 0)
    {
      printf ("-1, 0, 1/2, 1, 2, 3, 4, 5, 9, 27, 32 & 240 are O.K.\n");
      printf ("\n");
    }
  printf ("Searching for Radix and Precision.\n");
  W = One;
  do
    {
      W = W + W;
      Y = W + One;
      Z = Y - W;
      Y = Z - One;
    }
  while (MinusOne + FABS (Y) < Zero);
  /*.. now W is just big enough that |((W+1)-W)-1| >= 1 ... */
  Precision = Zero;
  Y = One;
  do
    {
      Radix = W + Y;
      Y = Y + Y;
      Radix = Radix - W;
    }
  while (Radix == Zero);
  if (Radix < Two)
    Radix = One;
  printf ("Radix = %s .\n", Radix.str());
  if (Radix != One)
    {
      W = One;
      do
	{
	  Precision = Precision + One;
	  W = W * Radix;
	  Y = W + One;
	}
      while ((Y - W) == One);
    }
  /*... now W == Radix^Precision is barely too big to satisfy (W+1)-W == 1
     ... */
  U1 = One / W;
  U2 = Radix * U1;
  printf ("Closest relative separation found is U1 = %s .\n\n", U1.str());
  printf ("Recalculating radix and precision\n ");

  /*save old values */
  E0 = Radix;
  E1 = U1;
  E9 = U2;
  E3 = Precision;

  X = Four / Three;
  Third = X - One;
  F6 = Half - Third;
  X = F6 + F6;
  X = FABS (X - Third);
  if (X < U2)
    X = U2;

  /*... now X = (unknown no.) ulps of 1+... */
  do
    {
      U2 = X;
      Y = Half * U2 + ThirtyTwo * U2 * U2;
      Y = One + Y;
      X = Y - One;
    }
  while (!((U2 <= X) || (X <= Zero)));

  /*... now U2 == 1 ulp of 1 + ... */
  X = Two / Three;
  F6 = X - Half;
  Third = F6 + F6;
  X = Third - Half;
  X = FABS (X + F6);
  if (X < U1)
    X = U1;

  /*... now  X == (unknown no.) ulps of 1 -... */
  do
    {
      U1 = X;
      Y = Half * U1 + ThirtyTwo * U1 * U1;
      Y = Half - Y;
      X = Half + Y;
      Y = Half - X;
      X = Half + Y;
    }
  while (!((U1 <= X) || (X <= Zero)));
  /*... now U1 == 1 ulp of 1 - ... */
  if (U1 == E1)
    printf ("confirms closest relative separation U1 .\n");
  else
    printf ("gets better closest relative separation U1 = %s .\n", U1.str());
  W = One / U1;
  F9 = (Half - U1) + Half;

  Radix = FLOOR (FLOAT ("0.01") + U2 / U1);
  if (Radix == E0)
    printf ("Radix confirmed.\n");
  else
    printf ("MYSTERY: recalculated Radix = %s .\n", Radix.str());
  TstCond (Defect, Radix <= Eight + Eight,
	   "Radix is too big: roundoff problems");
  TstCond (Flaw, (Radix == Two) || (Radix == 10)
	   || (Radix == One), "Radix is not as good as 2 or 10");
	/*=============================================*/
  Milestone = 20;
	/*=============================================*/
  TstCond (Failure, F9 - Half < Half,
	   "(1-U1)-1/2 < 1/2 is FALSE, prog. fails?");
  X = F9;
  I = 1;
  Y = X - Half;
  Z = Y - Half;
  TstCond (Failure, (X != One)
	   || (Z == Zero), "Comparison is fuzzy,X=1 but X-1/2-1/2 != 0");
  X = One + U2;
  I = 0;
	/*=============================================*/
  Milestone = 25;
	/*=============================================*/
  /*... BMinusU2 = nextafter(Radix, 0) */
  BMinusU2 = Radix - One;
  BMinusU2 = (BMinusU2 - U2) + One;
  /* Purify Integers */
  if (Radix != One)
    {
      X = -TwoForty * LOG (U1) / LOG (Radix);
      Y = FLOOR (Half + X);
      if (FABS (X - Y) * Four < One)
	X = Y;
      Precision = X / TwoForty;
      Y = FLOOR (Half + Precision);
      if (FABS (Precision - Y) * TwoForty < Half)
	Precision = Y;
    }
  if ((Precision != FLOOR (Precision)) || (Radix == One))
    {
      printf ("Precision cannot be characterized by an Integer number\n");
      printf
	("of significant digits but, by itself, this is a minor flaw.\n");
    }
  if (Radix == One)
    printf
      ("logarithmic encoding has precision characterized solely by U1.\n");
  else
    printf ("The number of significant digits of the Radix is %s .\n",
	    Precision.str());
  TstCond (Serious, U2 * Nine * Nine * TwoForty < One,
	   "Precision worse than 5 decimal figures  ");
	/*=============================================*/
  Milestone = 30;
	/*=============================================*/
  /* Test for extra-precise subexpressions */
  X = FABS (((Four / Three - One) - One / Four) * Three - One / Four);
  do
    {
      Z2 = X;
      X = (One + (Half * Z2 + ThirtyTwo * Z2 * Z2)) - One;
    }
  while (!((Z2 <= X) || (X <= Zero)));
  X = Y = Z = FABS ((Three / Four - Two / Three) * Three - One / Four);
  do
    {
      Z1 = Z;
      Z = (One / Two - ((One / Two - (Half * Z1 + ThirtyTwo * Z1 * Z1))
			+ One / Two)) + One / Two;
    }
  while (!((Z1 <= Z) || (Z <= Zero)));
  do
    {
      do
	{
	  Y1 = Y;
	  Y =
	    (Half - ((Half - (Half * Y1 + ThirtyTwo * Y1 * Y1)) + Half)) +
	    Half;
	}
      while (!((Y1 <= Y) || (Y <= Zero)));
      X1 = X;
      X = ((Half * X1 + ThirtyTwo * X1 * X1) - F9) + F9;
    }
  while (!((X1 <= X) || (X <= Zero)));
  if ((X1 != Y1) || (X1 != Z1))
    {
      BadCond (Serious, "Disagreements among the values X1, Y1, Z1,\n");
      printf ("respectively  %s,  %s,  %s,\n", X1.str(), Y1.str(), Z1.str());
      printf ("are symptoms of inconsistencies introduced\n");
      printf ("by extra-precise evaluation of arithmetic subexpressions.\n");
      notify ("Possibly some part of this");
      if ((X1 == U1) || (Y1 == U1) || (Z1 == U1))
	printf ("That feature is not tested further by this program.\n");
    }
  else
    {
      if ((Z1 != U1) || (Z2 != U2))
	{
	  if ((Z1 >= U1) || (Z2 >= U2))
	    {
	      BadCond (Failure, "");
	      notify ("Precision");
	      printf ("\tU1 = %s, Z1 - U1 = %s\n", U1.str(), (Z1 - U1).str());
	      printf ("\tU2 = %s, Z2 - U2 = %s\n", U2.str(), (Z2 - U2).str());
	    }
	  else
	    {
	      if ((Z1 <= Zero) || (Z2 <= Zero))
		{
		  printf ("Because of unusual Radix = %s", Radix.str());
		  printf (", or exact rational arithmetic a result\n");
		  printf ("Z1 = %s, or Z2 = %s ", Z1.str(), Z2.str());
		  notify ("of an\nextra-precision");
		}
	      if (Z1 != Z2 || Z1 > Zero)
		{
		  X = Z1 / U1;
		  Y = Z2 / U2;
		  if (Y > X)
		    X = Y;
		  Q = -LOG (X);
		  printf ("Some subexpressions appear to be calculated "
			  "extra precisely\n");
		  printf ("with about %s extra B-digits, i.e.\n",
			  (Q / LOG (Radix)).str());
		  printf ("roughly %s extra significant decimals.\n",
			  (Q / LOG (FLOAT (10))).str());
		}
	      printf
		("That feature is not tested further by this program.\n");
	    }
	}
    }
  Pause ();
	/*=============================================*/
  Milestone = 35;
	/*=============================================*/
  if (Radix >= Two)
    {
      X = W / (Radix * Radix);
      Y = X + One;
      Z = Y - X;
      T = Z + U2;
      X = T - Z;
      TstCond (Failure, X == U2,
	       "Subtraction is not normalized X=Y,X+Z != Y+Z!");
      if (X == U2)
	printf ("Subtraction appears to be normalized, as it should be.");
    }
  printf ("\nChecking for guard digit in *, /, and -.\n");
  Y = F9 * One;
  Z = One * F9;
  X = F9 - Half;
  Y = (Y - Half) - X;
  Z = (Z - Half) - X;
  X = One + U2;
  T = X * Radix;
  R = Radix * X;
  X = T - Radix;
  X = X - Radix * U2;
  T = R - Radix;
  T = T - Radix * U2;
  X = X * (Radix - One);
  T = T * (Radix - One);
  if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero))
    GMult = Yes;
  else
    {
      GMult = No;
      TstCond (Serious, false, "* lacks a Guard Digit, so 1*X != X");
    }
  Z = Radix * U2;
  X = One + Z;
  Y = FABS ((X + Z) - X * X) - U2;
  X = One - U2;
  Z = FABS ((X - U2) - X * X) - U1;
  TstCond (Failure, (Y <= Zero)
	   && (Z <= Zero), "* gets too many final digits wrong.\n");
  Y = One - U2;
  X = One + U2;
  Z = One / Y;
  Y = Z - X;
  X = One / Three;
  Z = Three / Nine;
  X = X - Z;
  T = Nine / TwentySeven;
  Z = Z - T;
  TstCond (Defect, X == Zero && Y == Zero && Z == Zero,
	   "Division lacks a Guard Digit, so error can exceed 1 ulp\n"
	   "or  1/3  and  3/9  and  9/27 may disagree");
  Y = F9 / One;
  X = F9 - Half;
  Y = (Y - Half) - X;
  X = One + U2;
  T = X / One;
  X = T - X;
  if ((X == Zero) && (Y == Zero) && (Z == Zero))
    GDiv = Yes;
  else
    {
      GDiv = No;
      TstCond (Serious, false, "Division lacks a Guard Digit, so X/1 != X");
    }
  X = One / (One + U2);
  Y = X - Half - Half;
  TstCond (Serious, Y < Zero, "Computed value of 1/1.000..1 >= 1");
  X = One - U2;
  Y = One + Radix * U2;
  Z = X * Radix;
  T = Y * Radix;
  R = Z / Radix;
  StickyBit = T / Radix;
  X = R - X;
  Y = StickyBit - Y;
  TstCond (Failure, X == Zero && Y == Zero,
	   "* and/or / gets too many last digits wrong");
  Y = One - U1;
  X = One - F9;
  Y = One - Y;
  T = Radix - U2;
  Z = Radix - BMinusU2;
  T = Radix - T;
  if ((X == U1) && (Y == U1) && (Z == U2) && (T == U2))
    GAddSub = Yes;
  else
    {
      GAddSub = No;
      TstCond (Serious, false,
	       "- lacks Guard Digit, so cancellation is obscured");
    }
  if (F9 != One && F9 - One >= Zero)
    {
      BadCond (Serious, "comparison alleges  (1-U1) < 1  although\n");
      printf ("  subtraction yields  (1-U1) - 1 = 0 , thereby vitiating\n");
      printf ("  such precautions against division by zero as\n");
      printf ("  ...  if (X == 1.0) {.....} else {.../(X-1.0)...}\n");
    }
  if (GMult == Yes && GDiv == Yes && GAddSub == Yes)
    printf
      ("     *, /, and - appear to have guard digits, as they should.\n");
	/*=============================================*/
  Milestone = 40;
	/*=============================================*/
  Pause ();
  printf ("Checking rounding on multiply, divide and add/subtract.\n");
  RMult = Other;
  RDiv = Other;
  RAddSub = Other;
  RadixD2 = Radix / Two;
  A1 = Two;
  Done = false;
  do
    {
      AInvrse = Radix;
      do
	{
	  X = AInvrse;
	  AInvrse = AInvrse / A1;
	}
      while (!(FLOOR (AInvrse) != AInvrse));
      Done = (X == One) || (A1 > Three);
      if (!Done)
	A1 = Nine + One;
    }
  while (!(Done));
  if (X == One)
    A1 = Radix;
  AInvrse = One / A1;
  X = A1;
  Y = AInvrse;
  Done = false;
  do
    {
      Z = X * Y - Half;
      TstCond (Failure, Z == Half, "X * (1/X) differs from 1");
      Done = X == Radix;
      X = Radix;
      Y = One / X;
    }
  while (!(Done));
  Y2 = One + U2;
  Y1 = One - U2;
  X = OneAndHalf - U2;
  Y = OneAndHalf + U2;
  Z = (X - U2) * Y2;
  T = Y * Y1;
  Z = Z - X;
  T = T - X;
  X = X * Y2;
  Y = (Y + U2) * Y1;
  X = X - OneAndHalf;
  Y = Y - OneAndHalf;
  if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T <= Zero))
    {
      X = (OneAndHalf + U2) * Y2;
      Y = OneAndHalf - U2 - U2;
      Z = OneAndHalf + U2 + U2;
      T = (OneAndHalf - U2) * Y1;
      X = X - (Z + U2);
      StickyBit = Y * Y1;
      S = Z * Y2;
      T = T - Y;
      Y = (U2 - Y) + StickyBit;
      Z = S - (Z + U2 + U2);
      StickyBit = (Y2 + U2) * Y1;
      Y1 = Y2 * Y1;
      StickyBit = StickyBit - Y2;
      Y1 = Y1 - Half;
      if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
	  && (StickyBit == Zero) && (Y1 == Half))
	{
	  RMult = Rounded;
	  printf ("Multiplication appears to round correctly.\n");
	}
      else if ((X + U2 == Zero) && (Y < Zero) && (Z + U2 == Zero)
	       && (T < Zero) && (StickyBit + U2 == Zero) && (Y1 < Half))
	{
	  RMult = Chopped;
	  printf ("Multiplication appears to chop.\n");
	}
      else
	printf ("* is neither chopped nor correctly rounded.\n");
      if ((RMult == Rounded) && (GMult == No))
	notify ("Multiplication");
    }
  else
    printf ("* is neither chopped nor correctly rounded.\n");
	/*=============================================*/
  Milestone = 45;
	/*=============================================*/
  Y2 = One + U2;
  Y1 = One - U2;
  Z = OneAndHalf + U2 + U2;
  X = Z / Y2;
  T = OneAndHalf - U2 - U2;
  Y = (T - U2) / Y1;
  Z = (Z + U2) / Y2;
  X = X - OneAndHalf;
  Y = Y - T;
  T = T / Y1;
  Z = Z - (OneAndHalf + U2);
  T = (U2 - OneAndHalf) + T;
  if (!((X > Zero) || (Y > Zero) || (Z > Zero) || (T > Zero)))
    {
      X = OneAndHalf / Y2;
      Y = OneAndHalf - U2;
      Z = OneAndHalf + U2;
      X = X - Y;
      T = OneAndHalf / Y1;
      Y = Y / Y1;
      T = T - (Z + U2);
      Y = Y - Z;
      Z = Z / Y2;
      Y1 = (Y2 + U2) / Y2;
      Z = Z - OneAndHalf;
      Y2 = Y1 - Y2;
      Y1 = (F9 - U1) / F9;
      if ((X == Zero) && (Y == Zero) && (Z == Zero) && (T == Zero)
	  && (Y2 == Zero) && (Y2 == Zero) && (Y1 - Half == F9 - Half))
	{
	  RDiv = Rounded;
	  printf ("Division appears to round correctly.\n");
	  if (GDiv == No)
	    notify ("Division");
	}
      else if ((X < Zero) && (Y < Zero) && (Z < Zero) && (T < Zero)
	       && (Y2 < Zero) && (Y1 - Half < F9 - Half))
	{
	  RDiv = Chopped;
	  printf ("Division appears to chop.\n");
	}
    }
  if (RDiv == Other)
    printf ("/ is neither chopped nor correctly rounded.\n");
  BInvrse = One / Radix;
  TstCond (Failure, (BInvrse * Radix - Half == Half),
	   "Radix * ( 1 / Radix ) differs from 1");
	/*=============================================*/
  Milestone = 50;
	/*=============================================*/
  TstCond (Failure, ((F9 + U1) - Half == Half)
	   && ((BMinusU2 + U2) - One == Radix - One),
	   "Incomplete carry-propagation in Addition");
  X = One - U1 * U1;
  Y = One + U2 * (One - U2);
  Z = F9 - Half;
  X = (X - Half) - Z;
  Y = Y - One;
  if ((X == Zero) && (Y == Zero))
    {
      RAddSub = Chopped;
      printf ("Add/Subtract appears to be chopped.\n");
    }
  if (GAddSub == Yes)
    {
      X = (Half + U2) * U2;
      Y = (Half - U2) * U2;
      X = One + X;
      Y = One + Y;
      X = (One + U2) - X;
      Y = One - Y;
      if ((X == Zero) && (Y == Zero))
	{
	  X = (Half + U2) * U1;
	  Y = (Half - U2) * U1;
	  X = One - X;
	  Y = One - Y;
	  X = F9 - X;
	  Y = One - Y;
	  if ((X == Zero) && (Y == Zero))
	    {
	      RAddSub = Rounded;
	      printf ("Addition/Subtraction appears to round correctly.\n");
	      if (GAddSub == No)
		notify ("Add/Subtract");
	    }
	  else
	    printf ("Addition/Subtraction neither rounds nor chops.\n");
	}
      else
	printf ("Addition/Subtraction neither rounds nor chops.\n");
    }
  else
    printf ("Addition/Subtraction neither rounds nor chops.\n");
  S = One;
  X = One + Half * (One + Half);
  Y = (One + U2) * Half;
  Z = X - Y;
  T = Y - X;
  StickyBit = Z + T;
  if (StickyBit != Zero)
    {
      S = Zero;
      BadCond (Flaw, "(X - Y) + (Y - X) is non zero!\n");
    }
  StickyBit = Zero;
  if ((GMult == Yes) && (GDiv == Yes) && (GAddSub == Yes)
      && (RMult == Rounded) && (RDiv == Rounded)
      && (RAddSub == Rounded) && (FLOOR (RadixD2) == RadixD2))
    {
      printf ("Checking for sticky bit.\n");
      X = (Half + U1) * U2;
      Y = Half * U2;
      Z = One + Y;
      T = One + X;
      if ((Z - One <= Zero) && (T - One >= U2))
	{
	  Z = T + Y;
	  Y = Z - X;
	  if ((Z - T >= U2) && (Y - T == Zero))
	    {
	      X = (Half + U1) * U1;
	      Y = Half * U1;
	      Z = One - Y;
	      T = One - X;
	      if ((Z - One == Zero) && (T - F9 == Zero))
		{
		  Z = (Half - U1) * U1;
		  T = F9 - Z;
		  Q = F9 - Y;
		  if ((T - F9 == Zero) && (F9 - U1 - Q == Zero))
		    {
		      Z = (One + U2) * OneAndHalf;
		      T = (OneAndHalf + U2) - Z + U2;
		      X = One + Half / Radix;
		      Y = One + Radix * U2;
		      Z = X * Y;
		      if (T == Zero && X + Radix * U2 - Z == Zero)
			{
			  if (Radix != Two)
			    {
			      X = Two + U2;
			      Y = X / Two;
			      if ((Y - One == Zero))
				StickyBit = S;
			    }
			  else
			    StickyBit = S;
			}
		    }
		}
	    }
	}
    }
  if (StickyBit == One)
    printf ("Sticky bit apparently used correctly.\n");
  else
    printf ("Sticky bit used incorrectly or not at all.\n");
  TstCond (Flaw, !(GMult == No || GDiv == No || GAddSub == No ||
		   RMult == Other || RDiv == Other || RAddSub == Other),
	   "lack(s) of guard digits or failure(s) to correctly round or chop\n\
(noted above) count as one flaw in the final tally below");
	/*=============================================*/
  Milestone = 60;
	/*=============================================*/
  printf ("\n");
  printf ("Does Multiplication commute?  ");
  printf ("Testing on %d random pairs.\n", NoTrials);
  Random9 = SQRT (FLOAT (3));
  Random1 = Third;
  I = 1;
  do
    {
      X = Random ();
      Y = Random ();
      Z9 = Y * X;
      Z = X * Y;
      Z9 = Z - Z9;
      I = I + 1;
    }
  while (!((I > NoTrials) || (Z9 != Zero)));
  if (I == NoTrials)
    {
      Random1 = One + Half / Three;
      Random2 = (U2 + U1) + One;
      Z = Random1 * Random2;
      Y = Random2 * Random1;
      Z9 = (One + Half / Three) * ((U2 + U1) + One) - (One + Half /
						       Three) * ((U2 + U1) +
								 One);
    }
  if (!((I == NoTrials) || (Z9 == Zero)))
    BadCond (Defect, "X * Y == Y * X trial fails.\n");
  else
    printf ("     No failures found in %d integer pairs.\n", NoTrials);
	/*=============================================*/
  Milestone = 70;
	/*=============================================*/
  printf ("\nRunning test of square root(x).\n");
  TstCond (Failure, (Zero == SQRT (Zero))
	   && (-Zero == SQRT (-Zero))
	   && (One == SQRT (One)), "Square root of 0.0, -0.0 or 1.0 wrong");
  MinSqEr = Zero;
  MaxSqEr = Zero;
  J = Zero;
  X = Radix;
  OneUlp = U2;
  SqXMinX (Serious);
  X = BInvrse;
  OneUlp = BInvrse * U1;
  SqXMinX (Serious);
  X = U1;
  OneUlp = U1 * U1;
  SqXMinX (Serious);
  if (J != Zero)
    Pause ();
  printf ("Testing if sqrt(X * X) == X for %d Integers X.\n", NoTrials);
  J = Zero;
  X = Two;
  Y = Radix;
  if ((Radix != One))
    do
      {
	X = Y;
	Y = Radix * Y;
      }
    while (!((Y - X >= NoTrials)));
  OneUlp = X * U2;
  I = 1;
  while (I <= NoTrials)
    {
      X = X + One;
      SqXMinX (Defect);
      if (J > Zero)
	break;
      I = I + 1;
    }
  printf ("Test for sqrt monotonicity.\n");
  I = -1;
  X = BMinusU2;
  Y = Radix;
  Z = Radix + Radix * U2;
  NotMonot = false;
  Monot = false;
  while (!(NotMonot || Monot))
    {
      I = I + 1;
      X = SQRT (X);
      Q = SQRT (Y);
      Z = SQRT (Z);
      if ((X > Q) || (Q > Z))
	NotMonot = true;
      else
	{
	  Q = FLOOR (Q + Half);
	  if (!(I > 0 || Radix == Q * Q))
	    Monot = true;
	  else if (I > 0)
	    {
	      if (I > 1)
		Monot = true;
	      else
		{
		  Y = Y * BInvrse;
		  X = Y - U1;
		  Z = Y + U1;
		}
	    }
	  else
	    {
	      Y = Q;
	      X = Y - U2;
	      Z = Y + U2;
	    }
	}
    }
  if (Monot)
    printf ("sqrt has passed a test for Monotonicity.\n");
  else
    {
      BadCond (Defect, "");
      printf ("sqrt(X) is non-monotonic for X near %s .\n", Y.str());
    }
	/*=============================================*/
  Milestone = 110;
	/*=============================================*/
  printf ("Seeking Underflow thresholds UfThold and E0.\n");
  D = U1;
  if (Precision != FLOOR (Precision))
    {
      D = BInvrse;
      X = Precision;
      do
	{
	  D = D * BInvrse;
	  X = X - One;
	}
      while (X > Zero);
    }
  Y = One;
  Z = D;
  /* ... D is power of 1/Radix < 1. */
  do
    {
      C = Y;
      Y = Z;
      Z = Y * Y;
    }
  while ((Y > Z) && (Z + Z > Z));
  Y = C;
  Z = Y * D;
  do
    {
      C = Y;
      Y = Z;
      Z = Y * D;
    }
  while ((Y > Z) && (Z + Z > Z));
  if (Radix < Two)
    HInvrse = Two;
  else
    HInvrse = Radix;
  H = One / HInvrse;
  /* ... 1/HInvrse == H == Min(1/Radix, 1/2) */
  CInvrse = One / C;
  E0 = C;
  Z = E0 * H;
  /* ...1/Radix^(BIG Integer) << 1 << CInvrse == 1/C */
  do
    {
      Y = E0;
      E0 = Z;
      Z = E0 * H;
    }
  while ((E0 > Z) && (Z + Z > Z));
  UfThold = E0;
  E1 = Zero;
  Q = Zero;
  E9 = U2;
  S = One + E9;
  D = C * S;
  if (D <= C)
    {
      E9 = Radix * U2;
      S = One + E9;
      D = C * S;
      if (D <= C)
	{
	  BadCond (Failure,
		   "multiplication gets too many last digits wrong.\n");
	  Underflow = E0;
	  Y1 = Zero;
	  PseudoZero = Z;
	  Pause ();
	}
    }
  else
    {
      Underflow = D;
      PseudoZero = Underflow * H;
      UfThold = Zero;
      do
	{
	  Y1 = Underflow;
	  Underflow = PseudoZero;
	  if (E1 + E1 <= E1)
	    {
	      Y2 = Underflow * HInvrse;
	      E1 = FABS (Y1 - Y2);
	      Q = Y1;
	      if ((UfThold == Zero) && (Y1 != Y2))
		UfThold = Y1;
	    }
	  PseudoZero = PseudoZero * H;
	}
      while ((Underflow > PseudoZero)
	     && (PseudoZero + PseudoZero > PseudoZero));
    }
  /* Comment line 4530 .. 4560 */
  if (PseudoZero != Zero)
    {
      printf ("\n");
      Z = PseudoZero;
      /* ... Test PseudoZero for "phoney- zero" violates */
      /* ... PseudoZero < Underflow or PseudoZero < PseudoZero + PseudoZero
         ... */
      if (PseudoZero <= Zero)
	{
	  BadCond (Failure, "Positive expressions can underflow to an\n");
	  printf ("allegedly negative value\n");
	  printf ("PseudoZero that prints out as: %s .\n", PseudoZero.str());
	  X = -PseudoZero;
	  if (X <= Zero)
	    {
	      printf ("But -PseudoZero, which should be\n");
	      printf ("positive, isn't; it prints out as  %s .\n", X.str());
	    }
	}
      else
	{
	  BadCond (Flaw, "Underflow can stick at an allegedly positive\n");
	  printf ("value PseudoZero that prints out as %s .\n",
		  PseudoZero.str());
	}
      TstPtUf ();
    }
	/*=============================================*/
  Milestone = 120;
	/*=============================================*/
  if (CInvrse * Y > CInvrse * Y1)
    {
      S = H * S;
      E0 = Underflow;
    }
  if (!((E1 == Zero) || (E1 == E0)))
    {
      BadCond (Defect, "");
      if (E1 < E0)
	{
	  printf ("Products underflow at a higher");
	  printf (" threshold than differences.\n");
	  if (PseudoZero == Zero)
	    E0 = E1;
	}
      else
	{
	  printf ("Difference underflows at a higher");
	  printf (" threshold than products.\n");
	}
    }
  printf ("Smallest strictly positive number found is E0 = %s .\n", E0.str());
  Z = E0;
  TstPtUf ();
  Underflow = E0;
  if (N == 1)
    Underflow = Y;
  I = 4;
  if (E1 == Zero)
    I = 3;
  if (UfThold == Zero)
    I = I - 2;
  UfNGrad = true;
  switch (I)
    {
    case 1:
      UfThold = Underflow;
      if ((CInvrse * Q) != ((CInvrse * Y) * S))
	{
	  UfThold = Y;
	  BadCond (Failure, "Either accuracy deteriorates as numbers\n");
	  printf ("approach a threshold = %s\n", UfThold.str());
	  printf (" coming down from %s\n", C.str());
	  printf
	    (" or else multiplication gets too many last digits wrong.\n");
	}
      Pause ();
      break;

    case 2:
      BadCond (Failure,
	       "Underflow confuses Comparison, which alleges that\n");
      printf ("Q == Y while denying that |Q - Y| == 0; these values\n");
      printf ("print out as Q = %s, Y = %s .\n", Q.str(), Y2.str());
      printf ("|Q - Y| = %s .\n", FABS (Q - Y2).str());
      UfThold = Q;
      break;

    case 3:
      X = X;
      break;

    case 4:
      if ((Q == UfThold) && (E1 == E0) && (FABS (UfThold - E1 / E9) <= E1))
	{
	  UfNGrad = false;
	  printf ("Underflow is gradual; it incurs Absolute Error =\n");
	  printf ("(roundoff in UfThold) < E0.\n");
	  Y = E0 * CInvrse;
	  Y = Y * (OneAndHalf + U2);
	  X = CInvrse * (One + U2);
	  Y = Y / X;
	  IEEE = (Y == E0);
	}
    }
  if (UfNGrad)
    {
      printf ("\n");
      if (setjmp (ovfl_buf))
	{
	  printf ("Underflow / UfThold failed!\n");
	  R = H + H;
	}
      else
	R = SQRT (Underflow / UfThold);
      if (R <= H)
	{
	  Z = R * UfThold;
	  X = Z * (One + R * H * (One + H));
	}
      else
	{
	  Z = UfThold;
	  X = Z * (One + H * H * (One + H));
	}
      if (!((X == Z) || (X - Z != Zero)))
	{
	  BadCond (Flaw, "");
	  printf ("X = %s\n\tis not equal to Z = %s .\n", X.str(), Z.str());
	  Z9 = X - Z;
	  printf ("yet X - Z yields %s .\n", Z9.str());
	  printf ("    Should this NOT signal Underflow, ");
	  printf ("this is a SERIOUS DEFECT\nthat causes ");
	  printf ("confusion when innocent statements like\n");;
	  printf ("    if (X == Z)  ...  else");
	  printf ("  ... (f(X) - f(Z)) / (X - Z) ...\n");
	  printf ("encounter Division by Zero although actually\n");
	  if (setjmp (ovfl_buf))
	    printf ("X / Z fails!\n");
	  else
	    printf ("X / Z = 1 + %s .\n", ((X / Z - Half) - Half).str());
	}
    }
  printf ("The Underflow threshold is %s, below which\n", UfThold.str());
  printf ("calculation may suffer larger Relative error than ");
  printf ("merely roundoff.\n");
  Y2 = U1 * U1;
  Y = Y2 * Y2;
  Y2 = Y * U1;
  if (Y2 <= UfThold)
    {
      if (Y > E0)
	{
	  BadCond (Defect, "");
	  I = 5;
	}
      else
	{
	  BadCond (Serious, "");
	  I = 4;
	}
      printf ("Range is too narrow; U1^%d Underflows.\n", I);
    }
	/*=============================================*/
  Milestone = 130;
	/*=============================================*/
  Y = -FLOOR (Half - TwoForty * LOG (UfThold) / LOG (HInvrse)) / TwoForty;
  Y2 = Y + Y;
  printf ("Since underflow occurs below the threshold\n");
  printf ("UfThold = (%s) ^ (%s)\nonly underflow ", HInvrse.str(), Y.str());
  printf ("should afflict the expression\n\t(%s) ^ (%s);\n",
	  HInvrse.str(), Y2.str());
  printf ("actually calculating yields:");
  if (setjmp (ovfl_buf))
    {
      BadCond (Serious, "trap on underflow.\n");
    }
  else
    {
      V9 = POW (HInvrse, Y2);
      printf (" %s .\n", V9.str());
      if (!((V9 >= Zero) && (V9 <= (Radix + Radix + E9) * UfThold)))
	{
	  BadCond (Serious, "this is not between 0 and underflow\n");
	  printf ("   threshold = %s .\n", UfThold.str());
	}
      else if (!(V9 > UfThold * (One + E9)))
	printf ("This computed value is O.K.\n");
      else
	{
	  BadCond (Defect, "this is not between 0 and underflow\n");
	  printf ("   threshold = %s .\n", UfThold.str());
	}
    }
	/*=============================================*/
  Milestone = 160;
	/*=============================================*/
  Pause ();
  printf ("Searching for Overflow threshold:\n");
  printf ("This may generate an error.\n");
  Y = -CInvrse;
  V9 = HInvrse * Y;
  if (setjmp (ovfl_buf))
    {
      I = 0;
      V9 = Y;
      goto overflow;
    }
  do
    {
      V = Y;
      Y = V9;
      V9 = HInvrse * Y;
    }
  while (V9 < Y);
  I = 1;
overflow:
  Z = V9;
  printf ("Can `Z = -Y' overflow?\n");
  printf ("Trying it on Y = %s .\n", Y.str());
  V9 = -Y;
  V0 = V9;
  if (V - Y == V + V0)
    printf ("Seems O.K.\n");
  else
    {
      printf ("finds a ");
      BadCond (Flaw, "-(-Y) differs from Y.\n");
    }
  if (Z != Y)
    {
      BadCond (Serious, "");
      printf ("overflow past %s\n\tshrinks to %s .\n", Y.str(), Z.str());
    }
  if (I)
    {
      Y = V * (HInvrse * U2 - HInvrse);
      Z = Y + ((One - HInvrse) * U2) * V;
      if (Z < V0)
	Y = Z;
      if (Y < V0)
	V = Y;
      if (V0 - V < V0)
	V = V0;
    }
  else
    {
      V = Y * (HInvrse * U2 - HInvrse);
      V = V + ((One - HInvrse) * U2) * Y;
    }
  printf ("Overflow threshold is V  = %s .\n", V.str());
  if (I)
    printf ("Overflow saturates at V0 = %s .\n", V0.str());
  else
    printf ("There is no saturation value because "
	    "the system traps on overflow.\n");
  V9 = V * One;
  printf ("No Overflow should be signaled for V * 1 = %s\n", V9.str());
  V9 = V / One;
  printf ("                           nor for V / 1 = %s.\n", V9.str());
  printf ("Any overflow signal separating this * from the one\n");
  printf ("above is a DEFECT.\n");
	/*=============================================*/
  Milestone = 170;
	/*=============================================*/
  if (!(-V < V && -V0 < V0 && -UfThold < V && UfThold < V))
    {
      BadCond (Failure, "Comparisons involving ");
      printf ("+-%s, +-%s\nand +-%s are confused by Overflow.",
	      V.str(), V0.str(), UfThold.str());
    }
	/*=============================================*/
  Milestone = 175;
	/*=============================================*/
  printf ("\n");
  for (Indx = 1; Indx <= 3; ++Indx)
    {
      switch (Indx)
	{
	case 1:
	  Z = UfThold;
	  break;
	case 2:
	  Z = E0;
	  break;
	case 3:
	  Z = PseudoZero;
	  break;
	}
      if (Z != Zero)
	{
	  V9 = SQRT (Z);
	  Y = V9 * V9;
	  if (Y / (One - Radix * E9) < Z || Y > (One + Radix * E9) * Z)
	    {			/* dgh: + E9 --> * E9 */
	      if (V9 > U1)
		BadCond (Serious, "");
	      else
		BadCond (Defect, "");
	      printf ("Comparison alleges that what prints as Z = %s\n",
		      Z.str());
	      printf (" is too far from sqrt(Z) ^ 2 = %s .\n", Y.str());
	    }
	}
    }
	/*=============================================*/
  Milestone = 180;
	/*=============================================*/
  for (Indx = 1; Indx <= 2; ++Indx)
    {
      if (Indx == 1)
	Z = V;
      else
	Z = V0;
      V9 = SQRT (Z);
      X = (One - Radix * E9) * V9;
      V9 = V9 * X;
      if (((V9 < (One - Two * Radix * E9) * Z) || (V9 > Z)))
	{
	  Y = V9;
	  if (X < W)
	    BadCond (Serious, "");
	  else
	    BadCond (Defect, "");
	  printf ("Comparison alleges that Z = %s\n", Z.str());
	  printf (" is too far from sqrt(Z) ^ 2 (%s) .\n", Y.str());
	}
    }
	/*=============================================*/
  Milestone = 190;
	/*=============================================*/
  Pause ();
  X = UfThold * V;
  Y = Radix * Radix;
  if (X * Y < One || X > Y)
    {
      if (X * Y < U1 || X > Y / U1)
	BadCond (Defect, "Badly");
      else
	BadCond (Flaw, "");

      printf (" unbalanced range; UfThold * V = %s\n\t%s\n",
	      X.str(), "is too far from 1.\n");
    }
	/*=============================================*/
  Milestone = 200;
	/*=============================================*/
  for (Indx = 1; Indx <= 5; ++Indx)
    {
      X = F9;
      switch (Indx)
	{
	case 2:
	  X = One + U2;
	  break;
	case 3:
	  X = V;
	  break;
	case 4:
	  X = UfThold;
	  break;
	case 5:
	  X = Radix;
	}
      Y = X;
      if (setjmp (ovfl_buf))
	printf ("  X / X  traps when X = %s\n", X.str());
      else
	{
	  V9 = (Y / X - Half) - Half;
	  if (V9 == Zero)
	    continue;
	  if (V9 == -U1 && Indx < 5)
	    BadCond (Flaw, "");
	  else
	    BadCond (Serious, "");
	  printf ("  X / X differs from 1 when X = %s\n", X.str());
	  printf ("  instead, X / X - 1/2 - 1/2 = %s .\n", V9.str());
	}
    }
	/*=============================================*/
  Milestone = 210;
	/*=============================================*/
  MyZero = Zero;
  printf ("\n");
  printf ("What message and/or values does Division by Zero produce?\n");
  printf ("    Trying to compute 1 / 0 produces ...");
  if (!setjmp (ovfl_buf))
    printf ("  %s .\n", (One / MyZero).str());
  printf ("\n    Trying to compute 0 / 0 produces ...");
  if (!setjmp (ovfl_buf))
    printf ("  %s .\n", (Zero / MyZero).str());
	/*=============================================*/
  Milestone = 220;
	/*=============================================*/
  Pause ();
  printf ("\n");
  {
    static const char *msg[] = {
      "FAILUREs  encountered =",
      "SERIOUS DEFECTs  discovered =",
      "DEFECTs  discovered =",
      "FLAWs  discovered ="
    };
    int i;
    for (i = 0; i < 4; i++)
      if (ErrCnt[i])
	printf ("The number of  %-29s %d.\n", msg[i], ErrCnt[i]);
  }
  printf ("\n");
  if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect] + ErrCnt[Flaw]) > 0)
    {
      if ((ErrCnt[Failure] + ErrCnt[Serious] + ErrCnt[Defect] == 0)
	  && (ErrCnt[Flaw] > 0))
	{
	  printf ("The arithmetic diagnosed seems ");
	  printf ("Satisfactory though flawed.\n");
	}
      if ((ErrCnt[Failure] + ErrCnt[Serious] == 0) && (ErrCnt[Defect] > 0))
	{
	  printf ("The arithmetic diagnosed may be Acceptable\n");
	  printf ("despite inconvenient Defects.\n");
	}
      if ((ErrCnt[Failure] + ErrCnt[Serious]) > 0)
	{
	  printf ("The arithmetic diagnosed has ");
	  printf ("unacceptable Serious Defects.\n");
	}
      if (ErrCnt[Failure] > 0)
	{
	  printf ("Potentially fatal FAILURE may have spoiled this");
	  printf (" program's subsequent diagnoses.\n");
	}
    }
  else
    {
      printf ("No failures, defects nor flaws have been discovered.\n");
      if (!((RMult == Rounded) && (RDiv == Rounded)
	    && (RAddSub == Rounded) && (RSqrt == Rounded)))
	printf ("The arithmetic diagnosed seems Satisfactory.\n");
      else
	{
	  if (StickyBit >= One &&
	      (Radix - Two) * (Radix - Nine - One) == Zero)
	    {
	      printf ("Rounding appears to conform to ");
	      printf ("the proposed IEEE standard P");
	      if ((Radix == Two) &&
		  ((Precision - Four * Three * Two) *
		   (Precision - TwentySeven - TwentySeven + One) == Zero))
		printf ("754");
	      else
		printf ("854");
	      if (IEEE)
		printf (".\n");
	      else
		{
		  printf (",\nexcept for possibly Double Rounding");
		  printf (" during Gradual Underflow.\n");
		}
	    }
	  printf ("The arithmetic diagnosed appears to be Excellent!\n");
	}
    }
  printf ("END OF TEST.\n");
  return 0;
}

template<typename FLOAT>
FLOAT
Paranoia<FLOAT>::Sign (FLOAT X)
{
  return X >= FLOAT (long (0)) ? 1 : -1;
}

template<typename FLOAT>
void
Paranoia<FLOAT>::Pause ()
{
  if (do_pause)
    {
      fputs ("Press return...", stdout);
      fflush (stdout);
      getchar();
    }
  printf ("\nDiagnosis resumes after milestone Number %d", Milestone);
  printf ("          Page: %d\n\n", PageNo);
  ++Milestone;
  ++PageNo;
}

template<typename FLOAT>
void
Paranoia<FLOAT>::TstCond (int K, int Valid, const char *T)
{
  if (!Valid)
    {
      BadCond (K, T);
      printf (".\n");
    }
}

template<typename FLOAT>
void
Paranoia<FLOAT>::BadCond (int K, const char *T)
{
  static const char *msg[] = { "FAILURE", "SERIOUS DEFECT", "DEFECT", "FLAW" };

  ErrCnt[K] = ErrCnt[K] + 1;
  printf ("%s:  %s", msg[K], T);
}

/* Random computes
     X = (Random1 + Random9)^5
     Random1 = X - FLOOR(X) + 0.000005 * X;
   and returns the new value of Random1.  */

template<typename FLOAT>
FLOAT
Paranoia<FLOAT>::Random ()
{
  FLOAT X, Y;

  X = Random1 + Random9;
  Y = X * X;
  Y = Y * Y;
  X = X * Y;
  Y = X - FLOOR (X);
  Random1 = Y + X * FLOAT ("0.000005");
  return (Random1);
}

template<typename FLOAT>
void
Paranoia<FLOAT>::SqXMinX (int ErrKind)
{
  FLOAT XA, XB;

  XB = X * BInvrse;
  XA = X - XB;
  SqEr = ((SQRT (X * X) - XB) - XA) / OneUlp;
  if (SqEr != Zero)
    {
      if (SqEr < MinSqEr)
	MinSqEr = SqEr;
      if (SqEr > MaxSqEr)
	MaxSqEr = SqEr;
      J = J + 1;
      BadCond (ErrKind, "\n");
      printf ("sqrt(%s) - %s  = %s\n", (X * X).str(), X.str(),
	      (OneUlp * SqEr).str());
      printf ("\tinstead of correct value 0 .\n");
    }
}

template<typename FLOAT>
void
Paranoia<FLOAT>::NewD ()
{
  X = Z1 * Q;
  X = FLOOR (Half - X / Radix) * Radix + X;
  Q = (Q - X * Z) / Radix + X * X * (D / Radix);
  Z = Z - Two * X * D;
  if (Z <= Zero)
    {
      Z = -Z;
      Z1 = -Z1;
    }
  D = Radix * D;
}

template<typename FLOAT>
void
Paranoia<FLOAT>::SR3750 ()
{
  if (!((X - Radix < Z2 - Radix) || (X - Z2 > W - Z2)))
    {
      I = I + 1;
      X2 = SQRT (X * D);
      Y2 = (X2 - Z2) - (Y - Z2);
      X2 = X8 / (Y - Half);
      X2 = X2 - Half * X2 * X2;
      SqEr = (Y2 + Half) + (Half - X2);
      if (SqEr < MinSqEr)
	MinSqEr = SqEr;
      SqEr = Y2 - X2;
      if (SqEr > MaxSqEr)
	MaxSqEr = SqEr;
    }
}

template<typename FLOAT>
void
Paranoia<FLOAT>::IsYeqX ()
{
  if (Y != X)
    {
      if (N <= 0)
	{
	  if (Z == Zero && Q <= Zero)
	    printf ("WARNING:  computing\n");
	  else
	    BadCond (Defect, "computing\n");
	  printf ("\t(%s) ^ (%s)\n", Z.str(), Q.str());
	  printf ("\tyielded %s;\n", Y.str());
	  printf ("\twhich compared unequal to correct %s ;\n", X.str());
	  printf ("\t\tthey differ by %s .\n", (Y - X).str());
	}
      N = N + 1;		/* ... count discrepancies. */
    }
}

template<typename FLOAT>
void
Paranoia<FLOAT>::PrintIfNPositive ()
{
  if (N > 0)
    printf ("Similar discrepancies have occurred %d times.\n", N);
}

template<typename FLOAT>
void
Paranoia<FLOAT>::TstPtUf ()
{
  N = 0;
  if (Z != Zero)
    {
      printf ("Since comparison denies Z = 0, evaluating ");
      printf ("(Z + Z) / Z should be safe.\n");
      if (setjmp (ovfl_buf))
	goto very_serious;
      Q9 = (Z + Z) / Z;
      printf ("What the machine gets for (Z + Z) / Z is %s .\n", Q9.str());
      if (FABS (Q9 - Two) < Radix * U2)
	{
	  printf ("This is O.K., provided Over/Underflow");
	  printf (" has NOT just been signaled.\n");
	}
      else
	{
	  if ((Q9 < One) || (Q9 > Two))
	    {
	    very_serious:
	      N = 1;
	      ErrCnt[Serious] = ErrCnt[Serious] + 1;
	      printf ("This is a VERY SERIOUS DEFECT!\n");
	    }
	  else
	    {
	      N = 1;
	      ErrCnt[Defect] = ErrCnt[Defect] + 1;
	      printf ("This is a DEFECT!\n");
	    }
	}
      V9 = Z * One;
      Random1 = V9;
      V9 = One * Z;
      Random2 = V9;
      V9 = Z / One;
      if ((Z == Random1) && (Z == Random2) && (Z == V9))
	{
	  if (N > 0)
	    Pause ();
	}
      else
	{
	  N = 1;
	  BadCond (Defect, "What prints as Z = ");
	  printf ("%s\n\tcompares different from  ", Z.str());
	  if (Z != Random1)
	    printf ("Z * 1 = %s ", Random1.str());
	  if (!((Z == Random2) || (Random2 == Random1)))
	    printf ("1 * Z == %s\n", Random2.str());
	  if (!(Z == V9))
	    printf ("Z / 1 = %s\n", V9.str());
	  if (Random2 != Random1)
	    {
	      ErrCnt[Defect] = ErrCnt[Defect] + 1;
	      BadCond (Defect, "Multiplication does not commute!\n");
	      printf ("\tComparison alleges that 1 * Z = %s\n", Random2.str());
	      printf ("\tdiffers from Z * 1 = %s\n", Random1.str());
	    }
	  Pause ();
	}
    }
}

template<typename FLOAT>
void
Paranoia<FLOAT>::notify (const char *s)
{
  printf ("%s test appears to be inconsistent...\n", s);
  printf ("   PLEASE NOTIFY KARPINKSI!\n");
}

/* ====================================================================== */

int main(int ac, char **av)
{
  init_real_once ();

  while (1)
    switch (getopt (ac, av, "pvg:fdl"))
      {
      case -1:
	return 0;
      case 'p':
	do_pause = true;
	break;
      case 'v':
	verbose = true;
	break;
      case 'g':
	{
	  int size = strtol (optarg, 0, 0);

	  switch (size)
	    {
	    case 32:
	      Paranoia< real_c_float<32, SFmode> >().main();
	      break;

	    case 64:
	      Paranoia< real_c_float<64, DFmode> >().main();
	      break;

	    case 96:
	      Paranoia< real_c_float<96, XFmode> >().main();
	      break;

	    case 128:
	      Paranoia< real_c_float<128, TFmode> >().main();
	      break;

	    default:
	      puts ("Invalid gcc implementation size.");
	      return 1;
	    }
	  break;
	}

      case 'f':
	Paranoia < native_float<float> >().main();
	break;
      case 'd':
	Paranoia < native_float<double> >().main();
	break;
      case 'l':
#ifndef NO_LONG_DOUBLE
	Paranoia < native_float<long double> >().main();
#endif
	break;

      case '?':
	puts ("-p\tpause between pages");
	puts ("-g<N>\treal.c implementation size N");
	puts ("-f\tnative float");
	puts ("-d\tnative double");
	puts ("-l\tnative long double");
	return 0;
      }
}

/* GCC stuff referenced by real.o.  */

extern "C" void
fancy_abort ()
{
  abort ();
}

int target_flags = 0;

extern "C"
enum machine_mode
mode_for_size (unsigned int size, enum mode_class, int)
{
  switch (size)
    {
    case 32:
      return SFmode;
    case 64:
      return DFmode;
    case 96:
      return XFmode;
    case 128:
      return TFmode;
    }
  abort ();
}