Add kwexpand and kwunexpand scripts.

Add kwexpand and kwunexpand scripts.

Add some blank lines to change file.

Test cvs keyword expansion

.gitattributes:
o Add filter for cvskeywords

qd-rep.lisp:
qd.lisp:
o Add $Id$ to test expansion

Add ident attribute for all Lisp files.

Add Id for testing gitattribute ident.

Add ident attribute

Add *oct-version*.

Export Jacobi functions and elliptic integrals.

Test carlson-rf and carlson-rd.

Add elliptic integrals of the second kind.

Implement elliptic integrals of the first kind.

o Add FLOAT-CONTAGION to determine the max precision of the given
  arguments so we can do appopriate contagion in the routines.
o Add some docstrings and other documentation of the algorithms.
o Add implmentation of ELLIPTIC-K and ELLIPTIC-F for the complete and
  incomplete elliptic integrals of the first kind, respectively.

Add documentation for EPSILON and add FLOAT-PI.

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

Move inline function NEG-QD-T before first use.

Oops.  Remove the #q reader functions from here.

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

Move #Q reader functions to new file qd-reader.lisp.

qd-reader.lisp:
o New file containing #Q reader functions.
o Create a new readtable containing our reader functions so we don't
  destructively modify the default *readtable*.

oct.asd:
o Add qd-reader.lisp.

qd-complex.lisp:
qd-elliptic.lisp:
qd-format.lisp:
o Set the *readtable* to *oct-readtable* before compiling these
  files.

For clisp, disable floating-point underflow when running tests.

Add elliptic K function and tests for it and Jacobi functions.

qd-elliptic.lisp:
o Add support for the complete elliptic integral K using Carlson's Rf
  function.

rt-tests.lisp:
o Fix indentation for oct.atan.5
o Add tests for elliptic K
o Add tests for Jacobi sn, cn, and dn functions.

Fix bug in qd-scale-float.

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

Oops.  Use jacobi-dn, not dn.

Clean up printing and fix printing bug in non-cmucl.

Clisp was printing #q(1 2) as #q(#q#q1 #q#q2).  This is caused by
PRINT-OBJECT for QD-COMPLEX printing a #q in addition to a #q printed
by QD-FORMAT.

qd-class.lisp:
o Use the same PRINT-OBJECT method for qd-real for all Lisps.
o Remove extraneous #q from PRINT-OBJECT method for qd-complex.

qd-io.lisp:
o QD-FORMAT for cmucl needs to output #q.

Support testing with Lisps without signed floating-point zeros.

CHECK-SIGN just returns T if Lisp thinks -0d0 and 0d0 are the same
number.  This is only true if Lisp doesn't support signed zeroes.

Fix issue with float-sign calling qfloat-sign.

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.

Ignore *.fas files.

Document algorithms better.

Oops. Can't use #q yet,so change #q1 to (make-qd-d 1d0).

Add support for Jacobi elliptic functions

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.

Remove extra blank lines.  Fix #1.

Note this defsystem is deprecated.  Fix #1.

Remove trailing empty lines.  Fix #1.

Add newline to end of file.  Fix #1.

Add newline to end of file.  Fix #1.

Add test-op for oct to run the tests.

The TARGET parameter is not a %QUAD-DOUBLE if we're not using
arrays to represent a %quad-double.

Ignore *~.

Ignore *.err files.

Fix typo and add tests for atanh

o Fix typo in number in for test oct.atan-branch-pos.2
o Add tests for atanh branch cuts.

Ignore more fasl files

Update Copyright dates.  No functional changes.

Update Copyright dates.  No functional changes.

Update Copyright dates.  No functional changes.

Move the configuration stuff out of the system definition files and
place them in qd-package.lisp.

Add additional tests.  These are taken from branch-test.lisp.

Change MAKE-FLOAT to multiply by the sign AFTER we've created the
quad-double.  This way we create signed quad-double zeroes correctly.
Previously, the sign was applied to the rational which loses the sign
if the rational is 0.

Ignore more fasls.

Add in-package.

o Use arrays if we're not running with cmucl.

Turn off compiler macros converting two-arg functions into CL
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.

For CMUCL, define compiler macros to convert two-arg-foo into the
appropriate CL function or QD-REAL function so we don't have to do
CLOS dispatch, if the types are known at compile-time.

Add or cleanup some docstrings.

Add or cleanup more docstrings.

Fix minor typo.

Add or cleanup some docstrings.

o For CMU, ignore target only if we're not using oct-arrays.
o Add implementation for SUB-QD-T.

Make default for CMUCL not to use arrays.  Some quick tests show that
currently arrays are slower or much slower than complex
double-doubles.

Adjust code so that CMUCL can use arrays to store quad-doubles instead
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.

Don't put initializers for the optional arg in the
define-compiler-macro.  This causes the same initializer object to be
used everywhere.  Instead, if no optional arg is given, call the
initializer in the expansion.

This fixes some issues with Allegro, and probably all other Lisps that
use don't have complex double-double-float objects.

Don't compile with safety 0 on Allegro.  I think this causes problems
on x86 because it doesn't quite keep the precision right.

Add ADD-QD-D-t, MUL-QD-D-T, and SQR-QD-T to declaim block.

Merge the changes from the THREE-ARG-BRANCH to HEAD.

Add Pade approximation for exp.  From Richard Fateman.

Experiments show that it is 25% faster than exp-qd/reduce.  However,
it loses 3 bits of accuracy compared with exp-qd/reduce.

Compare against pi/4 quad-double, not double-float.

MAKE-QD-DD is only defined for CMUCL, so don't unconditionally inline
it.

Add another implementation of REM-PI/2-INT.  This extracts just the
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.

qd-fun.lisp:
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.

o Add default implementation of float-infinity-p, float-nan-p,
  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.

Remove duplicate TIME-MUL.

Oops.  QDI package no longer exists.  Use OCTI.

Oops.  %MAKE-QD-D is a macro and not a function for some Lisps, so we
can't multiple-value-call it.  Rearrange code accordingly.

Remove CMUCL'isms.

qd-package.lisp:
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*
.

o Oops.  Fix up a few IN-PACKAGE's for the new package names.

o Oops.  Fix up a few IN-PACKAGE's for the new package names.

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 Rename QUAD-DOUBLE-INTERNAL package to OCT-INTERNAL, with nickname
  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.

qd.lisp:
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.

o Fix some typos accurate-sin-qd and accurate-cos-qd.
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.

Add +2/pi-bits+, 1584 bits of 2/pi.

o New routine to compute x mod pi/2 accurately, using many bits of
  2/pi.
o Implement accurate sin and cos routines to use this new routine.
  (Not used yet.)

Redo implementation of INTEGER-DECODE-QD.  It used to return way too
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.

Use package #:oct, not #:qd.

Correct the timing info.  I accidentally ran the C++ version on a
different (slower) machine.  The results make some sense now.

qd-const.lisp:
o Add code for clisp to create the constants we need.  (Clisp has
  arbitrary length long-float numbers.)
o Update the constants accordingly.
o Move the atan table stuff for CORDIC to qd-extra.lisp, since we
  don't need them in oct itself.

qd-extra.lisp:
o atan table stuff for CORDIC moved here.

Initial version.

Ignore *.lib and *.fas too.  (Files from clisp)

qd-io.lisp:
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

o Move logb-finite before first use.
o Declare arg as double-float, not float.

A new version of MAKE-FLOAT that converts the number to rational
before converting to a quad-double.  This reduces round-off errors.
This still needs work, I think.

Minor optimization converting a rational to a qd-real.  If the
denominator is 1, skip the qd-real division.

Use more bits (265 instead of 212) when converting a rational to a
quad-double.  This fixes the issue that converting 10^100 to a
quad-double isn't as accurate as it could be.

Add RATIONALIZE methods.  Algorithm graciously provided by Bruno
Haible.

qd-package.lisp:
o Shadow RATIONALIZE

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

MAKE-QD should handle rationals better instead of converting them to
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.

Add method RATIONAL to convert a quad-double to a rational.

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.

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

qd.lisp:
o Use the macro as needed.

qd-test.lisp:
o Add optional arg to enable/disable printing of results.  Default is
  on.

rt-tests.lisp:
o Don't print results.

New SCALE-FLOAT-QD implementation that shouldn't suffer from premature
overflow/underflow.  (Still issue if the exponent is very large or
very small, though, but not if the exponent is < 2000 or so.)

o Convert THREE-SUM2 to a macro instead of a function (to speed things
  up for Allegro and other Lisps that don't inline).
o Update code for the THREE-SUM2 macro.

o Fix typo in ADD-QD-DD that was introduced in the THREE-SUM macro
  conversion.
o Slightly simplify ADD-QD-DD too.

o Replace THREE-SUM with a macro to make sure it's inlined
  everywhere.
o Update code for new THREE-SUM macro.

Make %MAKE-QD-D a macro to make sure it's inlined.

o Remove old code.
o Inline float-infinity-p.