OCTI instead of QDI.
o Rename OCT package to NET.COMMON-LISP.OCT, with a nickname of OCT
o Remove nickname of QD.  (Conflicts with other packages dealing with
  quad-doubles.)
o Update all uses of QDI: to OCTI:

qd-fun.lisp:
o Add REM-PI/2 to do a simpler computation if the arg is small
  enough.  Otherwise, use the accurate but expensive rem operation.
o Renamed ACCURATE-SIN-QD to SIN-QD, etc.
o Update SIN-QD etc to use REM-PI/2.

o Add RATIONAL-TO-QD, a simple, fast and accurate method to convert
  rationals to quad-doubles.  (From Richard Fateman.)
o Use RATIONAL-TO-QD to create a quad-float

qd-methods.lisp:
o Use RATIONAL-TO-QD to create a quad-float from a bignum and ratio.

qd-package.lisp:
o Export RATIONAL-TO-QD

denominator is 1, skip the qd-real division.

Haible.

qd-package.lisp:
o Shadow RATIONALIZE

qd-methods.lisp:
o Add RATIONALIZE methods for CL:REAL's and QD-REAL's..

doubles and then converting the qd-real.  Convert the numerator and
denominator to qd-real, and the divide.  (This should be done better.)

qd-class.lisp:
o Change method to work on floats, instead of reals.

qd-methods.lisp:
o Add method to handle rationals.

qd-package.lisp:
o Appropriately shadow and export RATIONAL.
o Need to export WITH-QD-PARTS from QDI.

qd-methods.lisp:
o Define methods for RATIONAL for reals and qd-reals.

qd-complex.lisp:
o Use CL:RATIONAL as appropriate for the CL rational type.

o Rearrange some exports so the CMU ones are all grouped together.
o Export new constants pi/2, pi/4, 2pi, and log2.
o Export the qd-real and qd-complex types.

qd-methods.lisp:
o Define new constants for pi/2, pi/4, 2pi, and log2.
o Update some of the macrolets to work with a modern-mode lisp, like
  Allegro.

qd-complex.lisp:
o Use the new constants as needed.

o Oops.  Forgot to rename the defgenerics.

qd-complex.lisp:
o QLOG no longer exists.  Use LOG.

qd-methods.lisp:
o QLOG no longer exists.  Use LOG.

functions as methods directly.

o Shadow FLOAT-DIGITS

qd-methods.lisp:
o Add FLOAT-DIGITS method.

o Oops.  Move COERCE to qd-complex.lisp because we use the #q reader
  macro.  (This needs to be reorganized better.)
o Add RANDOM methods so we can generate quad-double random numbers.

qd-package.lisp:
o Shadow RANDOM so we can add our own RANDOM to generate quad-doubles.

qd-complex.lisp:
o COERCE moved here.

o Shadow CL:COERCE and export QD:COERCE

qd-methods.lisp:
o Define methods for COERCE so we can use COERCE with QD-REAL and
  QD-COMPLEX.

o Get rid of the #q reader that returns an internal %qd-real.

qd-methods.lisp:
o QPHASE was returning the wrong kind of object for positive values.
o Replace use of #q0 with the construction of a qd-real 0.

qd-const.lisp:
o Replace all uses of #q with #.(qd-from-string ...).

o Moved some methods from qd-methods.lisp to here.
o Was missing TWO-ARG-+ for qd-complex and qd-real (and vice versa)
o Fixed mistake in TWO-ARG-- (QD-COMPLEX REAL)
o Fixed mistake in TWO-ARG-- (QD-COMPLEX CL:COMPLEX)
o Was missing TWO-ARG-- (QD_COMPLEX QD-REAL) and vice versa.
o Was missing TWO-ARG-/ for (QD-REAL QD-COMPLEX)

qd-methods.lisp:
o Moved some methods from here to qd-methods.lisp
o Reimplement QFLOAT (RATIO QD-REAL) to use internal functions instead
  of calling TWO-ARG-/ and QFLOAT
o QABS (QD-COMPLEX) was returning the wrong thing.

from rationals because we need to coerce rationals to qd-reals to
preserve the desired accuracy.  Previously, the rationals were
converted to double-float, which loses accuracy.

  qd-real).
o Add +qd-real-one+ to hold 1 as a qd-real.

quad-double, and least-positive normalized quad-double.

o For CMU, try to print out infinities and NaN's nicely, instead of
  signaling an error.
o For QD-COMPLEX, print the components using #q notation inside the
  #q().

qd-methods.lisp:
o When reading #q(...), call READ to read the components so we can
  handle other stuff inside like #. and friends.

HYPOT-AUX-QD and HYPOT-QD.

log or not.

o SQRT-QD has round-off problems for very large and very small
  numbers.  Solve this by scaling the number by a power of 4 before
  computing the square root.
o Moved LOGB-FINITE and the core of QD-CSSQS to this file from
  qd-methods.lisp.  Rename the core routine as HYPOT-QD.
o Use it in ATAN-QD/NEWTON to get rid of unnecessary overflow.

qd-methods.lisp:
o Moved LOGB-FINITE and the core of QD-CSSQS from this file to
  qd-fun.lisp.  Use HYPOT-QD in QD-CSSQS.

qd-package.lisp:
o Export HYPOT-QD.

support infinities.

qd-class.lisp:
o Print out infinities.

qd-io.lisp:
o QD-FORMAT handles infinities

qd-methods.lisp:
o Add constants for positive and negative quad-double infinities.

qd-package.lisp:
o Export +PI+
o Export infinities.

o Remove QDI package qualifiers from exported functions.

corresponding two-arg-<foo> functions.

o Macroize the <, >, <=, and >= functions.

  single-float.
o Use QD-PARTS to extract the components in QFLOAT.  (Generates
  slightly better code on CMUCL.)

integers) to quad-doubles.