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.

  sub-d-qd, and neg-qd.
o Correct the compiler macros for CMUCL for sub-qd and sqr-qd.

o Add compiler macro for SQR-QD.

o Declare add-qd-t, mul-qd-t and div-qd-t as inline functions so that
  everything is still fast on cmucl.

consing by allowing the third argument to be a place where the result
can be stored.  This is intended to help reduce allocation and gc
costs for Lisps that use arrays to represent quad-doubles.

More work is needed to make the compiler macros do the right thing for
CMUCL.

qd-rep.lisp:
o Add %STORE-QD-D to store a quad-double into a place.  For CMUCL,
  there place argument is ignored and a fresh quad-double is created.

qd.lisp:
o Modify ADD-QD, SUB-QD, MUL-QD, and DIV-QD to take an optional third
  argument indicating where the result can be stored.   Ignored on
  CMUCL.
o Add ADD-QD-T, SUB-QD-T, MUL-QD-T, and DIV-QD-T, which are 3-arg
  functions with the third arg always required which is the storage
  area to hold the result.  Ignored on CMUCL.
o Add compiler macros to convert ADD-QD and friends to ADD-QD-T if the
  third arg is always given.  The effect is, essentially, inlining
  ADD-QD.

it.

  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.

o Oops.  In INTEGER-DECODE-QD, the signs of the parts were not
  computed correctly when combining them into the final integer
  result.

rt-tests.lisp:
o Add a test for INTEGER-DECODE-QD.
o Use OCT as the package, not QD.

many digits if one of the components was 0.  This causes problems
because the resulting integer can't even be coerced back to a
quad-double.

o Add macro WITH-QD-PARTS to extract the components of a quad-double.

qd.lisp:
o Use the macro as needed.

overflow/underflow.  (Still issue if the exponent is very large or
very small, though, but not if the exponent is < 2000 or so.)

  up for Allegro and other Lisps that don't inline).
o Update code for the THREE-SUM2 macro.

  conversion.
o Slightly simplify ADD-QD-DD too.

  everywhere.
o Update code for new THREE-SUM macro.

o Inline float-infinity-p.

All RT tests pass on CMUCL and Allegro.

qd-package.lisp:
o Don't import C::TWO-SUM anymore.

qd-dd.lisp:
o Make TWO-SUM a macro.

qd.lisp
o Add TWO-SUM macro for CMUCL (which just calls C::TWO-SUM).
o Update all uses of TWO-SUM to use the macro appropriately.

functions), change QUICK-TWO-SUM from a function to a macro.  Note
that macro has different calling convention than the function.  This
is needed because Allegro apparently doesn't handle VALUES without
boxing.

All rt tests pass.

qd-package.lisp:
o For CMUCL, don't import C::QUICK-TWO-SUM into the QDI package
  anymore.

qd-dd.lisp:
o New QUICK-TWO-SUM macro.

qd.lisp:
o Add CMUCL version of QUICK-TWO-SUM macro, which just calls
  C::QUICK-TWO-SUM.
o Update all users of QUICK-TWO-SUM appropriately.

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.

o Handle signed-zeroes in ABS-QD by checking sign of arg via float-sign, not minusp.

component wise tests.  Replace them with negation of the opposite
test.

A test case: (>= #q.999999999999999999999999999999q0 1) was returning
true because the quad-double is (1.0d0, -1.0d-30,
8.333642060758599d-47, -3.9501561822360763d-63), and 1.0d0 >= 1.0d0,
returning T.  This is wrong.

o Use QD-PARTS to get all parts of the %quad-double

o For CMUCL, produce infinities if an addition or multiplication would
  overflow.

the scale was very negative.  Change the implementation to fix that.

  code space.  Loop cost should be negligible.
o Fix typo in minusp-qd docstring.

o INTEGER-DECODE-QD wasn't working correctly when components are
  zero.  Hack this to make it work the way CMUCL does.  This should be
  changed.

quad-double.

qd-dd.lisp:
o Needed routines (taken from CMUCL)

qd.system:
o Compile qd-dd.lisp if needed.

qd-package.lisp:
o If on CMUCL, import the needed routines from the C package.

qd.lisp:
o Remove the C:: package qualifiers from the core double-double
  routines.

a portable presentation using a (simple-array double-float (4)) to
hold a %quad-double number.

All of the tests pass with the portable representation.

qd.lisp:
o Moved representation to qd-rep.lisp.
o INTEGER-DECODE-QD was dependent on the internal representation.
  Replace with a function using the appropriate accessors.

qd.system:
o Add new file qd-rep.lisp.

qd-rep.lisp:
o Representation moved here.
o Add portable implementation using a simple-array for holding a
  %quad-double.