The new method uses a table and the taylor series for atan to compute
atan for real args.

qd-const.lisp:
o Add the two tables used for the atan computation.
o Include clisp code that generates the tables.

qd-fun.lisp:
o Implement atan using a set of tables and a Taylor series.

timing.lisp:
o Add a simple timing program to evaluate how fast each atan method
  is.

o Remove old version
o Update new version to skip reduction if the arg <= pi/4.

o Implement better pi reduction and also always do pi reduction.
o Add test for sin(pi) and cos(2^120), to test pi reduction.
o Accuracy for erfc is only 198 bits.

of using a (complex double-double-float).

With these changes, CMUCL uses arrays and (rt:do-tests) passes
successfully.

oct.system:
o Push :oct-array onto *FEATURES* to use arrays.  This is the default
  if not building on CMUCL.

qd-fun.lisp:
o Fix two erroneous uses of zerop on a quad-double in sinh-qd and
  tanh-qd.
o Fix two erroneous uses of + on %quad-double; they should have used
  ADD-QD instead.

qd-rep.lisp:
o Change conditionalization to allow arrays for CMUCL.
o Update compiler macros appropriately.

qd.lisp:
o Adjust optional target arg appropriately for oct-array feature.
o Clean up IGNORE declarations.
o Add some more declarations for the target to make CMUCL happier.

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?)