                      Support code for

Algorithm xxx: Quadruple-Precision $\Gamma(x)$ and $\psi(x)$
                Functions for Real Arguments

                            and

   Algorithm xxx: GAUSSLOG --- A Package of Routines for
     Generating Gaussian Quadrature for Two Classes of
 Logarithmic Weight Functions and the Associated Orthogonal
                        Polynomials

                             by

                     Nelson H. F. Beebe
                            and
                       James S. Ball

                     University of Utah

                       [31-Jul-2000]
                   Revised: [15-Dec-2000]


=================
Table of Contents
=================

        Introduction
        Installation
        IBM RS/6000 and SGI systems
        Portland Group, Inc. Fortran compilers
        Non-IEEE 754 systems
        Non-POSIX-conformant operating systems
        Arithmetic-system-dependent constants
        Bug and problem reports
        Copyright issues
        Distribution contents


============
Introduction
============

The software in this package is described in detail in the
extensive articles

@String{j-TOMS                  = "ACM Transactions on Mathematical Software"}

@Article{Beebe:2000:AXG,
  author =       "Nelson H. F. Beebe and James S. Ball",
  title =        "Algorithm \emph{xxx}: {GAUSSLOG} --- {A} Package of
                 Routines for Generating {Gaussian} Quadrature for Two
                 Classes of Logarithmic Weight Functions and the
                 Associated Orthogonal Polynomials",
  journal =      j-TOMS,
  volume =       "26",
  number =       "??",
  pages =        "??--??",
  month =        "????",
  year =         "2000",
  CODEN =        "ACMSCU",
  ISSN =         "0098-3500",
  bibdate =      "Sat Dec 11 16:13:53 1999",
  acknowledgement = ack-nhfb,
}

@Article{Beebe:2000:AXQ,
  author =       "Nelson H. F. Beebe and James S. Ball",
  title =        "Algorithm \emph{xxx}: Quadruple-Precision $\Gamma(x)$
                 and $\psi(x)$ Functions for Real Arguments",
  journal =      j-TOMS,
  volume =       "26",
  number =       "??",
  pages =        "??--??",
  month =        "????",
  year =         "2000",
  CODEN =        "ACMSCU",
  ISSN =         "0098-3500",
  bibdate =      "Sat Dec 11 16:13:53 1999",
  acknowledgement = ack-nhfb,
}


============
Installation
============

As with most GNUware, you can build, test, and install this
program on most UNIX and POSIX-compliant systems by these
simple steps:

        env F77=Fortran-compiler-name ./configure && make all check install

You can override the default installation directory path
either at configure time, with the --prefix=path option, or
at "make install" (or "make uninstall") time:

        ./configure --prefix=/your/path/goes/here
        make prefix=/your/path/goes/here

The GNU standard default value for prefix is /usr/local; you
thus must have write access to that directory tree if you do
a default install. No special privileges are needed to
install in a private directory: I use prefix=$HOME/local on
systems where I do not have write access to /usr/local.

Please note that due to an irregularity in GNU autoconf, the
Fortran compiler name variable is F77 at "configure" time, but
FC at "make" time.  While I could repair this locally to
remove the inconsistency, the correction would be lost if
autoconf were run again at an end-user site.  At present,
GNU autoconf lacks a maintainer, so it is unknown when, or
if, this flaw in autoconf may be repaired.

You can set compiler optimization levels through the COPT
and FOPT variables on the make command line, for C/C++ and
Fortran respectively:

        make COPT=-xO3 FOPT='-xO5 -g3' targets...

You can let configure pick a default Fortran compiler by
simply doing

        ./configure && make -i all check install

It will then search for the first one found in this list:

        f77 g77 f90 f95

The code has been written very carefully to work under any
Fortran compiler conforming to ANSI/ISO Fortran 77, 90, 95,
or High-Performance Fortran.  Fortran 66 is NOT supported.

Some Fortran 90 and 95 compilers assume free-form source
format by default, in which case they need an extra flag to
revert to fixed-form source format.  configure will supply
this flag automatically where necessary for compilers on the
test systems at the development sites.  Most such compilers
more sensibly automatically assume fixed-form source format
for source file extension .f, and free-form format for
extensions .f90 and .f95.

This directory does not contain test programs for checking
the correct operation of the code here.  Instead, this is
relegated to "make check" runs in the associated directories

        ../gampsi
        ../jacobi
        ../laguerre

Thus, "make check" in this directory only produces a single
output message: ``There is no validation suite in this directory''.

The "make install" target will build and install a library
and header files, in the directory tree defined by the
prefix variable in the Makefile (set by configure by
default, or from its --prefix=path command-line option).
You can override prefix at install time, e.g., "make install
prefix=$HOME/local".

If you wish to undo a "make install", just do "make
uninstall"; this will remove any files in system directories
put there by "make install".  If you supplied a prefix
variable when you did "make install", you need to supply the
same one for "make uninstall".

Because not all Fortran implementations provide
quadruple-precision arithmetic, the default "make all check"
EXCLUDES builds and tests of the quadruple-precision
software.  You need to do "make all-qp" and/or "make
check-qp" to override this.

You can build and/or test just one precision with the
targets all-dp, all-qp, all-sp, check-dp, check-qp, and
check-qp.  Look in the Makefile to see how these further
cascade into tests of specific functions with particular
groups of test data, making it easy to repeat a particular
test that has failed, after a build with a different
compiler, or different compiler options.


===========================
IBM RS/6000 and SGI systems
===========================

As described at length in the articles (particularly the one
on the Gamma(x) function), these two architectures have a
different representation of quadruple-precision than others:
they use a pair of doubles instead.  This changes several
machine constants in *.inc and ../gampsi/*.inc.  As shown in
the article, patches can be easily, and RELIABLY, applied
with the GNU patch utility:

        patch < ibmsgi.pch

You can revert to the original versions by reversing the patch:

        patch -R < ibmsgi.pch

If you do not have patch installed, don't waste time making
the changes manually: fetch and install patch from its
distribution at

        ftp://ftp.gnu.org/gnu/patch

These patches MUST be applied before you can build
correctly-functioning versions of this software on the IBM
RS/6000 and SGI architectures!  Unlike C, Fortran lacks a
standard preprocessing facility, so we could not include
both versions of constants in one source file.


======================================
Portland Group, Inc. Fortran compilers
======================================

As documented in the article, the Portland Group, Inc. (PGI)
Fortran compilers (pgf77, pgf90, and pghpf, all version
3.1-3) generate incorrect code for the double-precision
Infinity and NaN tests, necessitating a complete rewrite of
the source code in those two functions.

The replacement code is supplied both as standalone source
files, isdinf.pgi and isdnan.pgi, which can be copied into
the corresponding .f files (but SAVE those files first!).
However, a better approach is to apply the updates via the
patch utility (discuss in an earlier section):

        patch < pgi.pch

You can then recover the original versions by reversing the
patch:

        patch -R < pgi.pch

The PGI replacement code has been carefully written to work
correctly on ALL of the tested systems, but is more complex
than should be necessary, particularly the one-liners shown
in the paper.


====================
Non-IEEE 754 systems
====================

The only significant non-IEEE 754 floating-point
architectures still in use in the year 2000 are:

        Compaq/DEC VAX
        Cray X-MP, Y-MP, C90
        IBM S/360

VAX systems will no longer be shipped after September 2000,
according to the vendor Web site at

        http://www.compaq.com/AlphaServer/vax/vax_now.html

Cray systems with non-IEEE 754 arithmetic are becoming
rarer.

IBM S/360 systems are common, but in 1999, IBM announced the
S/390 G5 processor with full support (in hardware) of
single-, double-, and quadruple-precision IEEE 754
arithmetic.  I suspect that older S/360 processors will
enjoy IEEE 754 support in software, if the compilers are
recent, so switch to it if possible, and leave the source
code of this package unchanged.

You will need to change machine constants in the *.inc and
../common/*.inc files according to the recipes documented in
their comments.  You will also likely need to change some,
or all, of the test data files, test/*.in, because the
ranges of numbers that they generate are chosen to match
IEEE 754 arithmetic, and the various approximation regions
used in the function evaluation.


======================================
Non-POSIX-conformant operating systems
======================================

Almost all operating systems today offer compliance with one
or more IEEE POSIX standards.  You can find a list of many
of them at

        http://www.math.utah.edu/pub/tex/bib/index-table-i.html#ieeestd

along with pointers to an IEEE catalog of standards.  You
can find a list of certified POSIX systems at

        http://standards.ieee.org/regauth/posix/index.html

which points to further lists at

        http://www.nist.gov/itl/div897/ctg/posix/finalreg4.htm
        http://standards.ieee.org/regauth/posix/posix2.html

Included among these are popular operating systems like
Microsoft Windows, Apple MacOS, and IBM VM/390.

However, just because a system can be made POSIX compliant,
does not imply that every such system is: indeed, you, or
your system manager, will almost certainly have had to
install additional packages to provide this compliance.

There are also multiple sources of UNIX-like environments on
top of Microsoft Windows: see

        http://www.math.utah.edu/~beebe/gnu-on-windows.html

for comments and pointers.

The configure scripts and Makefile should work cleanly in
all such environments (at one point during development, test
builds were done in a UNIX-on-Windows environment: the build
was successful, but rather slow).

If you cannot get a POSIX-conformant environment, then you
have to do things by hand:

* adjust constants in the *.inc files (unnecessary if your
  floating-point hardware is IEEE 754-conformant);

* compile the dist/common/*.f files, or at least the subset
  listed in the DLIBSRCS, QLIBSRCS, and SLIBSRCS variables
  in the dist/common/Makefile.in files;

* add the resulting object files to a suitable load library
  and install it in some convenient location for later use.

* copy the dist/*.h files to some place where your C
  compiler can find them easily

You will unfortunately not easily be able to run the
extensive validation suites launched by "make check" in
companion directories, so you will have no means of
validating the accuracy and correctness of the installed
software.  Proceeding-with-fingers-crossed is not a
recommended approach, particularly in view of the large
number of serious errors in vendor Fortran implementations
uncovered by our testing, but sometimes, it is all that you
can do, or have time for.


=====================================
Arithmetic-system-dependent constants
=====================================

The INCLUDE files in this directory are used by files in these
directories:

        ../common
        ../gampsi
        ../jacobi
        ../laguerre

They fall into five general classes:

(1) Permanent and immutable integer contants:

        ecodes.inc

    These must NEVER be changed; doing so would invalidate existing
    compiled code that used them.

(2) Problem-size constants:

        maxpts.inc

    These are chosen large enough that they should NEVER require
    modification.

(3) O/S-dependent or Fortran-implementation-dependent integer
    constants:

        stdio.inc

    The default values of stderr == 0, stddat == 1, stdin == 5, and
    stdout == 6 should work on the vast majority of POSIX-conformant
    and other operating systems.

(4) Architecture-INDEPENDENT floating-point constants required by the
    various numerical algorithms:

        acgam.inc
        al2pi2.inc
        cpsi.inc
        dcgam.inc
        dcpsi.inc
        dl2pi2.inc
        dlgtwo.inc
        qcgam.inc
        qcpsi.inc
        ql2pi2.inc
        qlgtwo.inc

    These are specified to sufficiently high precision that no changes
    should ever be needed until arithmetic systems with more than
    128-bit floating-point support become common.  None exist today,
    outside symbolic-algebra languages, Lisp- and Lisp-like languages,
    and multiple-precision libraries for various languages.  If, say,
    octuple-precision becomes available, then higher-precision
    approximations will be needed, and the algorithms for computation
    of gamma(x), psi(x), and related functions will have to be
    reexamined anyway.

(5) Floating-point-architecture-DEPENDENT constants:

        aeps.inc
        algtwo.inc
        axbig.inc
        axinf.inc
        axlarg.inc
        axmax1.inc
        axmin.inc
        axsmal.inc
        deps.inc
        dxbig.inc
        dxinf.inc
        dxmin.inc
        qeps.inc
        qxbig.inc
        qxinf.inc
        qxlarg.inc
        qxmax1.inc
        qxmin.inc
        qxsmal.inc

   The code and algorithms have been developed primarily for
   floating-point architectures that conform reasonably closely to
   IEEE 754 arithmetic.  In the year 2000, this is the case with
   virtually all computer architectures designed after 1980.  The only
   significant exceptions are IBM S/390 hexadecimal normalization
   floating-point arithmetic, DEC VAX arithmetic, and Cray 1, 2, X-MP,
   and Y-MP arithmetic.  Except for the IBM S/390, these systems are
   no longer actively marketed, though they may continue to run for a
   few more years at customer sites.  On IBM S/390, as discussed in
   our paper, the G5 and G6 processors provide hardware support for
   IEEE 754 arithmetic, and software emulation is provided for older
   processors.

   Nevertheless, if you port this code to a non-IEEE-754 system,
   changes will be required in each of the files listed above.
   Floating-point environmental enquiry facilities are simply too
   limited, too nonstandard, and too unreliable to use in place of
   compile-time constants.  Each of those INCLUDE files contains a
   comment header describing what the constant is, and a short Maple
   program showing how to compute it to high precision.  If Maple is
   unavailable, any competent scientific programmer should be able to
   express those simple computations in another symbolic algebra
   language, such at Axiom, Mathematica, MuPaD, or Reduce, to
   determine suitable values.


=======================
Bug and problem reports
=======================

Please send notification of bugs and problems with this
package, and news about ports to any new systems, to the
first author:

        Nelson H. F. Beebe
        Center for Scientific Computing
        University of Utah
        Department of Mathematics, 322 INSCC
        155 S 1400 E RM 233
        Salt Lake City, UT 84112-0090
        USA
        Email: beebe@math.utah.edu, beebe@acm.org, beebe@computer.org,
               beebe@ieee.org (Internet)
        WWW URL: http://www.math.utah.edu/~beebe
        Telephone: +1 801 581 5254
        FAX: +1 801 585 1640, +1 801 581 4148


================
Copyright issues
================

This code is distributed under the usual copyright
arrangement for the ACM Algorithms, as described from time
to time in the journal ACM Transactions on Mathematical
Software.  In general, the copyright provides for
unrestricted use of the software, in both commercial and
noncommercial software.


=====================
Distribution contents
=====================

The distribution file gampsi.tar.gz is a gzipped UNIX tar
archive containing this directory tree:

        dist/common/
        dist/common/save/
        dist/gampsi/
        dist/gampsi/maple/
        dist/gampsi/save/
        dist/gampsi/test/
        dist/gampsi/test/okay/

Alternatively, the distribution from the quadrature article
may contain

        dist/common/
        dist/common/save/
        dist/jacobi
        dist/laguerre

Thus, unbundling the distribution will produce only a single
file, the subdirectory dist, in the current directory.

Here is a summary of the files:

dist/gampsi/*                   Code for testing the Gamma(x) and psi(x)
                                functions.  See dist/gampsi/README for details.

dist/jacobi/*                   Code for testing the Gauss-Jacobi logarithmic
                                quadrature routines.  See dist/jacobi/README
                                for details.

dist/laguerre/*                 Code for testing the Gauss-Laguerre logarithmic
                                quadrature routines.  See dist/laguerre/README
                                for details.

dist/common/Makefile.in         Makefile template used by configure to generate
                                Makefile.  NEVER edit Makefile by hand: your
                                changes will be lost the next time configure is
                                run.  Instead, override variables on the make
                                command line, e.g., "make FOPT=-xO5".

dist/common/acgam.inc           Include file with single-precision coefficients
                                of the asymptotic series for ln(Gamma(x)).

dist/common/aeps.f              Single-precision machine-epsilon function.

dist/common/aeps.inc            Include file with single-precision
                                machine-epsilon constant; see the articles
                                about why both a function and a preset constant
                                are used.

dist/common/afpmax.f            Single-precision function to return the maximum
                                finite representable floating-point number.

dist/common/ainf.f              Single-precision function to return a run-time
                                trappable Infinity.

dist/common/airan.f             Single-precision function to return a
                                pseudo-random integer value in (a,b),
                                represented as a floating-point value.

dist/common/al2pi2.inc          Include file with single-precision values of
                                ln(2*pi)/2.

dist/common/algtwo.inc          Include file with single-precision values of
                                ln(2) and 1/ln(2).

dist/common/alog2.f             Single-precision function to compute the base-2
                                logarithm.

dist/common/anan.f              Single-precision function to return a run-time
                                trappable NaN.

dist/common/astore.f            Subroutine to force storage to memory of a
                                single-precision value.

dist/common/astorf.f            Function to force storage to memory of a
                                single-precision value, and to return that
                                value.

dist/common/axbig.inc           Include file with constant needed by algam.f
                                and gamma.f.

dist/common/axinf.inc           Include file with constant needed by gamma.f
                                and psi.f.

dist/common/axlarg.inc          Include file with constant needed by  psi.f.

dist/common/axmax1.inc          Include file with constant needed by psi.f.

dist/common/axmin.inc           Include file with constant needed by gamma.f
                                and psi.f.

dist/common/axsmal.inc          Include file with constant needed by psi.f.

dist/common/chkdgam.f           Program to check dgamma()'s Pad{\'e}
                                approximation for bit loss.

dist/common/chkiran.f           Program to write a file of results from
                                airan(), for debugging failures in test
                                vector x values.

dist/common/chkqgam.f           Program to check qgamma()'s Pad{\'e}
                                approximation for bit loss.

dist/common/chkqpsi.f           Program to check qpsi()'s Pad{\'e}
                                approximation for bit loss.

dist/common/chkran.f            Program to write a file of results from
                                ran(), for debugging failures in test
                                vector x values.

dist/common/common.sok          Spelling exception dictionary for text files in
                                this directory: "spell +common.sok file(s)"
                                runs a spell check.

dist/common/configure           GNU autoconf script, run prior to building the
                                software to create the Makefile with suitable
                                settings of variables.  You do NOT need
                                autoconf installed to use the configure script!

dist/common/configure.in        GNU autoconf template, used by autoconf to
                                produce configure and Makefile.  You should
                                not need to run this, unless you have changed
                                configure.in, in which case, after running it,
                                do "make configure" to create a patched
                                configure file.

dist/common/cpsi.inc            Include file with single-precision coefficients
                                of the asymptotic series for psi(x).

dist/common/dcgam.inc           Include file with double-precision coefficients
                                of the asymptotic series for ln(Gamma(x)).

dist/common/dcopy.f             Level-1 BLAS vector copy utility.

dist/common/dcpsi.inc           Include file with double-precision coefficients
                                of the asymptotic series for psi(x).

dist/common/deps.f              Double-precision machine-epsilon function.

dist/common/deps.inc            Include file with double-precision
                                machine-epsilon constant; see the articles
                                about why both a function and a preset constant
                                are used.

dist/common/derbit.f            Double-precision function to convert a relative
                                error to a bit error.

dist/common/dfloat.f            Double-precision function to convert an integer
                                to a floating-point value.  Though widely
                                implemented as a Fortran intrinsic, this
                                function was regrettably omitted from ANSI/ISO
                                Fortran 77.  While that functionality was
                                provided in Fortran 77 by the generic dble()
                                function, if it was used, portability to
                                Fortran 66 environments was compromised.

dist/common/dfpmax.f            Double-precision function to return the maximum
                                finite representable floating-point number.

dist/common/dgamint.f           Double-precision interface to return dgamma(x)
                                from qgamma(x).  Used only during testing.

dist/common/dgamma.f            Double-precision function to return Gamma(x).

dist/common/dinf.f              Double-precision function to return a run-time
                                trappable Infinity.

dist/common/diran.f             Double-precision function to return a
                                pseudo-random integer value in (a,b),
                                represented as a floating-point value.

dist/common/dl2pi2.inc          Include file with double-precision values of
                                ln(2*pi)/2.

dist/common/dlgtwo.inc          Include file with double-precision values of
                                ln(2) and 1/ln(2).

dist/common/dlog2.f             Double-precision function to compute the base-2
                                logarithm.

dist/common/dnan.f              Double-precision function to return a run-time
                                trappable NaN.

dist/common/dpsi.f              Double-precision function to return psi(x).

dist/common/dpsiint.f           Double-precision interface to return dpsi(x)
                                from qpsi(x).  Used only during testing.

dist/common/dpsiln.f            Double-precision function to return
                                psi(x)-ln(x).

dist/common/dpsum.f             Double-precision subroutine to update positive
                                and negative term summations.

dist/common/dran.f              Double-precision pseudo-random number generator.

dist/common/dstore.f            Subroutine to force storage to memory of a
                                double-precision value.

dist/common/dstorf.f            Function to force storage to memory of a
                                double-precision value, and to return that
                                value.

dist/common/dxbig.inc           Include file with constant needed by dlgam.f
                                and dgamma.f.

dist/common/dxinf.inc           Include file with constant needed by dgamma.f
                                and dpsi.f.

dist/common/dxmin.inc           Include file with constant needed by dgamma.f
                                and dpsi.f.

dist/common/ecodes.inc          Standard error codes for the quadrature
                                routines.

dist/common/ffalse.f            Fortran function to return .FALSE. (for use
                                from  C/C++ code)

dist/common/ftrue.f             Fortran function to return .TRUE. (for use
                                from C/C++ code)

dist/common/gamma.f             Single-precision function to return Gamma(x).

dist/common/ibmsgi.pch          Patch file for generating IBM RS/6000 and SGI
                                version of the source code in this directory.
                                See the section ``IBM RS/6000 and SGI systems''
                                above.

dist/common/iceil.f             Function to return ceil(x) for single-precision
                                x.

dist/common/idceil.f            Function to return ceil(x) for double-precision
                                x.

dist/common/iqceil.f            Function to return ceil(x) for
                                quadruple-precision x.

dist/common/isainf.f            LOGICAL function to test whether a
                                single-precision argument is Infinity or not.

dist/common/isanan.f            LOGICAL function to test whether a
                                single-precision argument is NaN or not.

dist/common/isdinf.f            LOGICAL function to test whether a
                                double-precision argument is Infinity or not.

dist/common/isdinf.pgi          LOGICAL function to test whether a
                                double-precision argument is Infinity or not
                                for Portland Group, Inc. compilers (pgf77,
                                pgf90, pghpf) bug workaround.  See the
                                dist/common/pgi.pch file comments below.

dist/common/isdnan.f            LOGICAL function to test whether a
                                double-precision argument is NaN or not.

dist/common/isdnan.pgi          LOGICAL function to test whether a
                                double-precision argument is NaN or not
                                for Portland Group, Inc. compilers (pgf77,
                                pgf90, pghpf) bug workaround.  See the
                                dist/common/pgi.pch file comments below.

dist/common/isqinf.f            LOGICAL function to test whether a
                                quadruple-precision argument is Infinity or not.

dist/common/isqnan.f            LOGICAL function to test whether a
                                quadruple-precision argument is NaN or not.

dist/common/machid.sh           Shell script to produce a
                                VENDOR-HARDWARE-OS-LEVEL report on stdout, for
                                use in labeling graphs.

dist/common/maxpts.inc          Include file to set the limit on internal array
                                sizes in the quadrature packages.

dist/common/pgi.pch             Patch file to convert isdinf.f to the contents
                                of isdinf.pgi, and isdnan.f to the contents of
                                isdnan.pgi.  See the section ``Portland Group,
                                Inc. Fortran compilers'' above.

dist/common/prthdr.f            Subroutine to print a standard test output
                                header for the quadrature package tests.

dist/common/psi.f               Single-precision function to return psi(x).

dist/common/psiln.f             Single-precision function to return
                                psi(x)-ln(x).

dist/common/pythag.f            Double-precision function to compute the
                                Euclidean 2-norm.  See the quadrature article
                                for a discussion.

dist/common/qcgam.inc           Include file with quadruple-precision
                                coefficients of the asymptotic series for
                                ln(Gamma(x)).

dist/common/qcpsi.inc           Include file with quadruple-precision
                                coefficients of the asymptotic series for
                                psi(x).

dist/common/qeps.f              Quadruple-precision machine-epsilon function.

dist/common/qeps.inc            Include file with quadruple-precision
                                machine-epsilon constant; see the articles
                                about why both a function and a preset constant
                                are used.

dist/common/qepsln.f            Double-precision function from EISPACK/2 for
                                computing the machine epsilon.  See the articles
                                for a discussion of why it sometimes fails.

dist/common/qfloat.f            Quadruple-precision function to convert an
                                integer to a floating-point value.  Though
                                widely implemented as a Fortran intrinsic, it
                                is not part of any ANSI/ISO Fortran Standard,
                                because quadruple-precision is not officially
                                supported by any such Standard.

dist/common/qfpmax.f            Quadruple-precision function to return the
                                maximum finite representable floating-point
                                number.

dist/common/qgamma.f            Quadruple-precision function to return Gamma(x).

dist/common/qinf.f              Quadruple-precision function to return a
                                run-time trappable Infinity.

dist/common/qiran.f             Quadruple-precision function to return a
                                pseudo-random integer value in (a,b),
                                represented as a floating-point value.

dist/common/ql2pi2.inc          Include file with quadruple-precision values of
                                ln(2*pi)/2.

dist/common/qlgtwo.inc          Include file with quadruple-precision values of
                                ln(2) and 1/ln(2).

dist/common/qlog2.f             Quadruple-precision function to compute the
                                base-2 logarithm.

dist/common/qnan.f              Quadruple-precision function to return a
                                run-time trappable NaN.

dist/common/qpsi.f              Quadruple-precision function to return psi(x).

dist/common/qpsiln.f            Quadruple-precision function to return
                                psi(x)-ln(x).

dist/common/qstore.f            Subroutine to force storage to memory of a
                                quadruple-precision value.

dist/common/qstorf.f            Function to force storage to memory of a
                                quadruple-precision value, and to return that
                                value.

dist/common/qxbig.inc           Include file with constant needed by qlgam.f
                                and qgamma.f.

dist/common/qxinf.inc           Include file with constant needed by qgamma.f
                                and qpsi.f.

dist/common/qxlarg.inc          Include file with constant needed by qpsi.f.

dist/common/qxmax1.inc          Include file with constant needed by qpsi.f.

dist/common/qxmin.inc           Include file with constant needed by qgamma.f
                                and qpsi.f.

dist/common/qxsmal.inc          Include file with constant needed by qpsi.f.

dist/common/ran.f               Single-precision pseudo-random number generator.

dist/common/save/Makefile       Backup copy of dist/common/Makefile, for use in
                                the event configure fails to complete.

dist/common/save/configure      Backup copy of dist/common/configure, for use in
                                the event configure is destroyed by a bad
                                autoconf.

dist/common/stdio.inc           Include file with standard unit numbers, as
                                chosen by IBM in the 1950s.  Although there
                                have since been historical compilers that
                                unwisely had different assignments for these
                                units, every system tested followed IBM's lead,
                                and thus, this file should never require
                                modification.

dist/common/tepsln.f            Test program to compare depsln() with deps().

dist/common/tqepsln.f           Test program to compare qepsln() with qeps().

dist/common/tql1.f              EISPACK/2 routine to find eigenvalues of a
                                tridiagonal matrix

dist/common/trapit.f            Subroutine to use with Sun Solaris
                                ieee_handler() used in commented-out code in
                                ../jacobi/*.f and ../laguerre/*.f.

dist/common/which.sh            Shell script to replace the "which" command to
                                look up a program in the search path, because
                                that command is broken on several UNIX systems.

-------------------------------------The End------------------------------------
