FLOAT-PI returns a value of pi that matches the precision of the
argument.

They've been moved to qd-reader.lisp.

MAKE-QD-D returns a %quad-double, not qd-real.  Use +QD-REAL-ONE+
instead.

If the optional arg to FLOAT-SIGN is not given, don't call qfloat-sign
with a second arg of NIL.  This breaks things.  Call qfloat-sign with
the same number of arguments as float-sign.

qd-elliptic.lisp:
o Implementation for Jacobi sn, cn, and dn functions.

qd-methods.lisp:
o Add EPSILON method to return the floating-point epsilon value for
  the given float.

oct.asd:
o Build qd-elliptic.lisp.

functions or QD-REAL functions.  They don't handle all the cases.  If
we're going to make this CMUCL-specific, deftransforms would be much
easier and much better.

appropriate CL function or QD-REAL function so we don't have to do
CLOS dispatch, if the types are known at compile-time.

  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.