o Fix typo in compiler macro for sub-d-qd

qd.lisp:
o Use 3-arg versions in div-qd-t to speed things up.  Approximately
  doubles the speed with clisp.

qd-fun.lisp:
o Use 3-arg versions in sqrt-qd to speed things up.  Approximately
  doubles the speed with clisp.

part of 2/pi that is needed to compute the desired result instead of
multiplying by all l584 bits of 2/pi.

Not yet used.

o Remove extra rem-pi/2-int.

qd-rep.lisp:
o Fix typo in float-infinity-p for Allegro.
o Ignore var in float-infinity-p and friends.

  float-trapping-nan-p.  These return NIL by default, unless the Lisp
  implementation has a suitable version.
o Remove CMU conditionalization for float-infinity-p, float-nan-p,
  float-trapping-nan-p.

o Don't :USE CMUCL's EXTENSIONS package anymore.  Import just the
  symbols we need.

qd-class.lisp:
o No need to use package qualifiers.

qd-fun.lisp:
o Need package qualifier for MAYBE-INLINE.

qd.lisp:
o Need package qualifier for *INLINE-EXPANSION-LIMIT*
.

qd-fun.lisp:
o Comment out the old sin/cos routines
o Fix a few mistakes in accurate-sincos-qd
o Rename accurate-sincos-qd to sincos-qd.

  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 Adjust code in accurate-sin-qd and accurate-cos-qd to handle values
  of 0 <= j <= 3, instead of -1 <= j <= 2.
o Add accurate-sincos-qd.

  2/pi.
o Implement accurate sin and cos routines to use this new routine.
  (Not used yet.)

o Declare arg as double-float, not float.

o Remove unused var R1 in EXP-QD/REDUCE.
o TAN-QD was calling ZEROP instead of ZEROP-QD.
o Comment out extra copy of ASINH-QD.

qd-io.lisp:
o Ignore unused var in QD-PRINT-EXPONENT and QD-READER.

qd.lisp:
o Remove extra version of DIV-QD.

qd-fun.lisp:
o Move implementations and timing/test functions to other file.

qd-extra.lisp:
o Stuff here.

qd.system:
o Add new system for the extra stuff.

o sqrt(inf) = inf
o expm1(+/-inf) = inf or +0
o log1p(inf) = inf
o log(inf) = inf
o log(+0) = -inf (but signal overflow)
o sinh(+/-inf) = +/-inf
o asinh(+/-inf) = +/-inf

infinity, if traps are disabled.

would set the threshold to 0 and we'd never exit the loop.  (Should we
change the threshold to be something else?  if x is less than about
1d-33, we don't need any more terms of the taylor series.)

o Oops.  Desired iteration was chosen incorrectly if xx and yy had
  different signs.

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.

  tighter.
o Rearrange the computations in LOG-QD/HALLEY to get rid of premature
  overflow.
o Improve TANH-QD so we don't get spurious overflows.  Leave the
  possibility of producing very accurate values of TANH-QD for large
  arguments.

handle larger numbers.  We still have problems for numbers near
MOST-POSITIVE-DOUBLE-FLOAT, though.

the loop is tiny compared to any quad-double operation.  This makes
the code smaller too.

o ATAN2-QD supports signed zeroes.  (Except for the 0,0 case, where it
  produces an error.  Should this be fixed?)

o Update timings for sparc.

o Don't inline agm-qd
o Update times for ppc and x86.

  qd.lisp and friends
o create QUAD-DOUBLE package for the quad-double class.
o Update in-package forms appropriately.
o Export the necessary QUAD-DOUBLE-INTERNAL symbols so QUAD-DOUBLE can
  use them.

in case we add a package that shadows these operations for real
quad-double integration.