1 SCIPORT
   SCIPORT is a portable implementation of CRAY SCILIB that provides
   both single and double precision object libraries; SCIPORTS provides
   single precision and SCIPORTD provides double precision.

   To have either of the libraries installed where they are not
   already available, contact Scott Lamson of ISO at 387-5795.

1 blas
   Basic Linear Algebra Subprograms --- a group of subprograms that perform
   operations using absolute values, vector arithmetic, array copying and
   swapping, Givens plane rotation, Euclidean norms, indexes of minimum and
   maximum values, vector summing, etc.

2 ISAMAX
   An integer function that returns the index of the first occurence of the
   element in a real vector with the largest absolute value.

       Call from FORTRAN:

             index = ISAMAX(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 ICAMAX
   An integer function that returns the index of the first occurence of the
   element in a complex vector with the largest absolute value.

       Call from FORTRAN:

             index = ICAMAX(n,cx,incx)

           n     Number of elements to process in vector cx.
           cx    Complex vector to be searched.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

2 SASUM
   A real function that returns the sum of the absolute values of a real
   vector.

       Call from FORTRAN:

             sum = SASUM(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be summed.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 SCASUM
   A real function that returns the sum of the absolute values of a complex
   vector.

       Call from FORTRAN:

             csum = SCASUM(n,cx,incx)

           n     Number of elements to process in vector cx.
           cx    Complex vector to be summed.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

2 SAXPY
   A subroutine that adds a real scalar multiple of one real vector to
   another real vector.

       Call from FORTRAN:

             CALL SAXPY(n,sa,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sa    Real scalar multiplier.
           sx    Real vector.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real result vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

2 CAXPY
   A subroutine that adds a complex scalar multiple of one complex vector
   to another complex vector.

       Call from FORTRAN:

             CALL CAXPY(n,ca,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           ca    Complex scalar multiplier.
           cx    Complex vector.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex result vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

2 SCOPY
   A subroutine that copies one real vector to another.

       Call from FORTRAN:

             CALL SCOPY(n,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sx    Real vector to be copied.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real result vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

2 CCOPY
   A subroutine that copies one complex vector to another.

       Call from FORTRAN:

             CALL CCOPY(n,cx,incx,cy,incy)

           n     Number of elements in vectors.
           cx    Complex vector to be copied.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex result vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

2 SDOT
   A real function that computes the inner (dot) product of two real
   vectors.

       Call from FORTRAN:

             dot = SDOT(n,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sx    Real vector operand.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real vector operand.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

2 CDOTC
   A complex function that computes the inner (dot) product of the 
   complex conjugate of one complex vector with another complex vector.

       Call from FORTRAN:

             cdot = CDOTC(n,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           cx    Complex vector operand.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector operand.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

2 CDOTU
   A complex function that computes the inner (dot) product of two complex
   vectors.

       Call from FORTRAN:

             cdot = CDOTU(n,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           cx    Complex vector operand.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector operand.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

2 SNRM2
   A real function that computes the Euclidean norm of a real vector.

       Call from FORTRAN:

             eucnorm = SNRM2(n,sx,incx)

           n     Number of elements in vector.
           sx    Real vector operand
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

       See page 4-10 of CRAY-1 Computer Systems - Library Reference Manual,
       SR-0014, for equation.

2 SCNRM2
   A real function that computes the Euclidean norm of a complex vector.

       Call from FORTRAN:

             eucnorm = SCNRM2(n,cx,incx)

           n     Number of elements in vector.
           cx    Complex vector operand
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

       See page 4-11 of CRAY-1 Computer Systems - Library Reference Manual,
       SR-0014, for equation.

2 SROTG
   A subroutine that computes the elements of a Givens rotation matrix.

       Call from FORTRAN:

             CALL SROTG(a,b,c,s)

           a     scalar supplied by user which returns the computed
                 value, r.
           b     scalar supplied by user which returns the computed
                 value, z.
           c     scalar cosine of rotation matrix (computed).
           s     scalar sine of rotation matrix (computed).

       See page 4-12 of CRAY-1 Library Reference Manual for equations.

2 SROT
   A subroutine that performs a matrix multiplication.  If the coefficients
   c and s satisfy c*c+s*s=1.0, the transformation is a Givens rotation.
   The matrix multiplication is a (2 by 2) times a (2 by n) and is used to
   modify coordinates (x,y).

       Call from FORTRAN:

             CALL SROT(n,sx,incx,sy,incy,c,s)

           n     Number of elements in vectors.
           sx    Real vector to be modified.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real vector to be modified.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.
           c     Real cosine normally calculated using SROTG.
           s     Real sine normally calculated using SROTG.

       See page 4-13 of CRAY-1 Library Reference Manual for additional
       information.

2 SROTMG
   A subroutine that computes the elements of a modified Givens plane
   rotation matrix.

       Call from FORTRAN:
 
             CALL SROTMG(d1,d2,b1,b2,param)

           d1     Input scale factor (updated on output).
           d2     Input scale factor (updated on output).
           b1     Input scalar (updated on output).
           b2     Input scalar.
           param  A five element array containing output parameters.

       See pages 4-13 to 4-19 of CRAY-1 Library Reference Manual for
       additional information.

2 SROTM
   A subroutine that applies the modified Givens plane rotation con-
   structed by SROTMG.

       Call from FORTRAN:

             CALL SROTM(n,sx,incx,sy,incy,param)

           n      Number of elements in vectors.
           sx     Real vector.
           incx   Skip distance between elements of sx.  For contiguous
                  elements, incx = 1.
           sy     Real vector.
           incy   Skip distance between elements of sy.  For contiguous
                  elements, incy = 1.
           param  A five element array containing input parameters that
                  are normally calculated using SROTMG.

       See pages 4-19 to 4-21 of CRAY-1 Library Reference Manual for
       additional information.

2 SSCAL
   This subroutine scales a real vector by multiplying it by a real
   number.

       Call from FORTRAN:

             CALL SSCAL(n,sa,sx,incx)

           n     Number of elements in vector.
           sa    Real scaling factor.
           sx    Real vector to be scaled.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 CSSCAL
   This subroutine scales a complex vector by multiplying it by a real
   number.

       Call from FORTRAN:

             CALL CSSCAL(n,sa,cx,incx)

           n     Number of elements in vector.
           sa    Real scaling factor.
           cx    Complex vector to be scaled.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

2 CSCAL
   This subroutine scales a complex vector by multiplying it by a complex
   number.

       Call from FORTRAN:

             CALL CSCAL(n,ca,cx,incx)

           n     Number of elements in vector.
           ca    Complex scaling factor.
           cx    Complex vector to be scaled.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

2 SSWAP
   A subroutine that exchanges two real vectors.

       Call from FORTRAN:

             CALL SSWAP(n,sx,incx,sy,incy)

           n     Number of elements in vectors.
           sx    One real vector.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Another real vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

2 CSWAP
   A subroutine that exchanges two complex vectors.

       Call from FORTRAN:

             CALL CSWAP(n,cx,incx,cy,incy)

           n     Number of elements in vectors.
           cx    One complex vector.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Another complex vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

2 SPAXPY
   A subroutine that is a useful primitive for the lower upper factor-
   ization and solution of sparse linear systems.  It is defined in
   FORTRAN in the following way:

                 DO 10 I=1,N
             10  SY(INDEX(I))=SA*SX(I)+SY(INDEX(I))

       Call from FORTRAN:

             CALL SPAXPY(n,sa,sx,sy,index)

           n      Number of elements in the vectors.
           sa     Real scalar multiplier.
           sx     Real vector operand.
           sy     Real vector operand.
           index  Vector of indexes.

2 SPDOT
   A real function that is a useful primitive for the lower upper
   factorization and solution of sparse linear systems.  It is defined
   in FORTRAN in the following way:

                 DO 10 I=1,N
             10  PDOT=PDOT+SY(INDEX(I))*SX(I)

       Call from FORTRAN:

             pdot = SPDOT(n,sy,index,sx)

           n      Number of elements in the vectors.
           sx     Real vector operand.
           sy     Real vector operand.
           index  Vector of indexes.

2 ISMAX
   An integer function that returns the first index of the largest 
   element of a real vector.

       Call from FORTRAN:

             imax = ISMAX(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 ISMIN
   An integer function that returns the first index of the smallest
   element of a real vector.

       Call from FORTRAN:

             imin = ISMIN(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 ISAMIN
   An integer function that returns the first index of the element with
   the smallest absolute value.

       Call from FORTRAN:

             imin = ISAMIN(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 SSUM
   A real function that sums the elements of a real vector.

       Call from FORTRAN:

             sum = SSUM(n,sx,incx)

           n     Number of elements in vector.
           sx    Real vector to be summed.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

2 CSUM
   A complex function that sums the elements of a complex vector.

       Call from FORTRAN:

             sum = CSUM(n,cx,incx)

           n     Number of elements in vector.
           cx    Complex vector to be summed.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

2 CROTG
   A subroutine that computes the elements of a complex Givens plane
   rotation matrix.

       Call from FORTRAN:

             CALL CROTG(ca,cb,cc,cs)

           ca    Complex number supplied by user which returns with a
                 computed value.
           cb    Complex number supplied by user which returns with a
                 computed value.
           cc    Complex cosine of rotation matrix (computed).
           cs    Complex sine of rotation matrix (computed).

       See page 4-28 of CRAY-1 Library Reference Manual for equation.

2 CROT
   A subroutine that applies the complex Givens plane rotation computed by
   the subroutine CROTG.

       Call from FORTRAN:

             CALL CROT(n,cx,incx,cy,incy,cc,cs)

           n     Number of elements in vectors.
           cx    Complex vector to be modified.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector to be modified.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.
           cc    Complex cosine normally calculated using CROTG.
           cs    Complex sine normally calculated using CROTG.

       See page 4-28 of CRAY-1 Library Reference Manual for equation.

2 SMACH
   A function that returns machine constants for the real limits of a
   given machine.

       Call from FORTRAN:

             x = SMACH(job)

           job = 1     The machine epsilon (the smallest number epsilon
                       such that (1. + e <> 1) and (1. - e <> 1)).
               = 2     A number close to smallest normalized, represent-
                       able number.
               = 3     A number close to largest normalized, representable
                       number.

2 CMACH
   A function that returns machine constants for the complex limits of a
   given machine.

       Call from FORTRAN:

             x = CMACH(job)

           job = 1     The machine epsilon (the smallest number epsilon
                       such that (1. + e <> 1) and (1. - e <> 1)).
               = 2     A number close to the square root of the smallest
                       normalized, representable number.
               = 3     A number close to the square root of the largest
                       normalized, representable number.

1 fft
   Fast Fourier Transforms --- a group of subprograms that apply a fast
   Fourier transform and compute either a Fourier analysis or a Fourier
   synthesis.

2 CFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL CFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 < 0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m for the
                 CRAY-1.
           x     Input vector.  Vector of n complex values.
           work  Working storage.  Vector of (5/2)n complex values.
           y     Result vector.  Vector of n complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, pages 4-51 to 4-52.

2 RCFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL RCFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 <=0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m.
           x     Input vector.  Vector of n real values.
           work  Working storage.  Vector of (3/2)n+2 complex values.
           y     Result vector.  Vector of (n/2)+1 complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, page 4-52.

2 CRFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL CRFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 <=0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m.
           x     Input vector.  Vector of (n/2)+1 complex values.
           work  Working storage.  Vector of (3/2)n+2 complex values.
           y     Result vector.  Vector of n complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, page 4-53.

1 filter_routs
   A group of subprograms used for filter analysis and design.  They can
   also be used to solve more general problems.

2 FILTERG
   A subroutine that computes a convolution of two vectors.

       Call from FORTRAN:

             CALL FILTERG(a,m,d,n,o)

           a     Vector of filter coefficients.
           m     Number of filter coefficients.
           d     Input data vector.
           n     Number of data points.
           o     Output vector.

   For additional information, see pages 4-53 to 4-54 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

2 FILTERS
   A subroutine that computes the same convolution of two vectors as
   FILTERG except that it assumes the filter coefficient vector is 
   symmetric.

       Call from FORTRAN:

             CALL FILTERS(a,m,d,n,o)

           a     Symmetric filter coefficient vector.
           m     M is formally the length of vector A but 
                 because A is symmetric, only m/2 elements
                 of A are ever referenced.
           d     Input data vector.
           n     Number of data points.
           o     Output vector.

   For additional information, see pages 4-54 to 4-55 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

2 OPFILT
   A subroutine that computes the solution to the Weiner-Levinson system of
   linear equations Ta=b where T is a Toeplitz matrix in which elements are
   described by the following:

                 t(i,j)=R(k)  for abs(j-i)+1=k
                                and k=1,...,n.

       Call from FORTRAN:

             CALL OPFILT(m,a,b,c,r)

           m     Order of system of equations.
           a     Output vector of filter coefficients.
           b     Information auto-correlation vector.
           c     Scratch vector of length 2m.
           r     Signal auto-correlation vector.

   For additional information, see pages 4-55 to 4-56 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

1 gath_scat
   A pair of subroutines that allow the user to gather a vector from a
   source vector or to scatter a vector into another vector.  A third
   vector of indexes determines which elements are accessed or changed.

2 GATHER
   A subroutine that allows the user to gather a vector from a source
   vector as in the following way:

             A(I) = B(INDEX(I))  where I=1,N.

       Call from FORTRAN:

             CALL GATHER(n,a,b,index)

           n      Number of elements in the vectors.
           a      Output vector.
           b      Source vector.
           index  Vector of indexes.

2 SCATTER
   A subroutine that allows the user to scatter a vector into another
   vector as in the following way:

             A(INDEX(I)) = B(I)

       Call from FORTRAN:

             CALL SCATTER(n,a,index,b)

           n      Number of elements in each vector.
           a      Output vector.
           index  Vector of indexes.
           b      Source vector.

1 linear_rec
   A group of subprograms that solve first-order and some second-order
   linear recurrences.  A linear recurrence is an evaluation of a
   quantity term by term from given initial values and from previously
   computed values.

2 FOLR
   A subroutine that solves first-order linear recurrences where vector B
   is overwritten by result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = -A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula on input and vector
                 C of formula on output. (The output overwrites
                 the input.)
           incb  Skip distance between elements of the vector
                 operand B and result C.  For contiguous
                 elements, incb = 1.

2 FOLRP
   A subroutine that solves first-order linear recurrences where vector B
   is overwritten by result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLRP(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula on input and vector
                 C of formula on output. (The output overwrites
                 the input.)
           incb  Skip distance between elements of the vector
                 operand B and result C.  For contiguous
                 elements, incb = 1.

2 FOLR2
   A subroutine that solves first-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = -A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR2(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector C of above formula.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.

2 FOLR2P
   A subroutine that solves first-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR2P(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector C of above formula.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.

2 FOLRN
   A real function that solves for the last term of a first-order
   linear recurrence where vector B is overwritten by result C.  It
   has the form:

              DO 10 I = 2,N
           10   B(I) = -A(I) * B(I-1) + B(I)

       Call from FORTRAN:

             result = FOLRN(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above formula. (The
                 output overwrites the input.)
           incb  Skip distance between elements of the vector
                 operand and result B.  For contiguous
                 elements, incb = 1.

2 SOLR
   A subroutine that solves second-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              DO 10 I = 1,N
           10   C(I+2) = A(I) * C(I+1) + B(I) * C(I)

       Call from FORTRAN:

             CALL SOLR(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

2 SOLRN
   A real function that solves for the last term of a second-order
   linear recurrence with input vectors A and B and result vector C.
   It has the form:

              DO 10 I = 1,N
           10   C(I+2) = A(I) * C(I+1) + B(I) * C(I)

       Call from FORTRAN:

             result = SOLR(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

2 SOLR3
   A subroutine that computes a second-order linear recurrence of three
   terms.  It has input vectors A and B and result vector C, and is of
   the form:

              DO 10 I = 1,N
           10   C(I+2) = C(I+2) + A(I)*C(I+1) + B(I)*C(I)

       Call from FORTRAN:

             CALL SOLR3(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

1 matrix_util
   A group of subroutines that compute a matrix inverse, solve systems
   of linear equations using Gauss-Jordan elimination, and provide for
   optimal matrix multiplication for different categories of matrices.

2 MINV
   A subroutine that computes the determinant and inverse of a square
   matrix and can also solve several systems of linear equations.

       Call from FORTRAN:  CALL MINV(ab,n,nd,scratch,det,eps,m,mode)

           ab      Augmented matrix of the square matrix A and the
                   n x m matrix B of the right-hand sides for each
                   system of equations to solve.  The solution over-
                   writes the corresponding right-hand side.  In the
                   calling routine, AB must be dimensioned A(nd,n+m).
           n       Order of matrix A.
           nd      Leading dimension of AB.
           scratch User-defined working storage array of length at
                   least 2*n.
           det     Determinant of matrix A.
           eps     Uuser-defined tolerance for the product of pivot
                   elements.
           m       > 0  Number of systems of linear equations to solve
                   = 0  Determinant of A is computed, depending on the
                        value of MODE.
           mode    +1   A is overwritten with A inverse
                   =0   A is not saved and A inverse is not computed.
2 MXM
   A subroutine that computes a matrix times matrix product (C=AB) and
   assumes a skip distance between elements of the matrices to be 1.

       Call from FORTRAN:

             CALL MXM(a,nar,b,nac,c,nbc)

           a     First matrix of product.
           nar   Number of rows of matrices A and C.
           b     Second matrix of product.
           nac   Number of columns of matrix A and the number of
                 rows of matrix B.
           c     Result matrix.
           nbc   Number of columns of matrices B and C.

2 MXV
   A subroutine that computes a matrix times a vector and assumes a
   skip distance between elements of the matrix to be 1.  Performs
   the following FORTRAN calculations:

                 DO 10 I = 1,NAR
              10   C(I)=A(I,1)*B(1)+A(I,2)*B(2)+...+A(I,NBR)*B(NBR)

       Call from FORTRAN:

             CALL MXV(a,nar,b,nbr,c)

           a     Matrix of product.
           nar   Number of rows of matrices A and C.
           b     Vector of product.
           nbr   Number of elements of vector B and the number
                 of columns of matrix A.
           c     Resulting vector.

2 MXMA
   A subroutine that computes a matrix times matrix product (C=AB) and
   allows for arbitrary spacing of matrix elements.

       Call from FORTRAN:

             CALL MXMA(a,na,iad,b,nb,ibd,c,nc,icd,nar,nac,nbc)

           a     First matrix of product.
           na    Spacing between column elements of A.
           iad   Spacing between row elements of A.
           b     Second matrix of product.
           nb    Spacing between column elements of B.
           ibd   Spacing between row elements of B.
           c     Output matrix.
           nc    Spacing between column elements of C.
           icd   Spacing between row elements of C.
           nar   Number of rows in first operand and result.
           nac   Number of columns in first operand and 
                 number of rows in second operand.
           nbc   Number of columns in second operand and 
                 result.

2 MXVA
   A subroutine that computes a matrix times a vector and allows for
   arbitrary spacing of matrix elements.

       Call from FORTRAN:

             CALL MXVA(a,na,iad,b,nb,c,nc,nar,nbr)

           a     Matrix of product.
           na    Spacing between column elements of A.
           iad   Spacing between row elements of A.
           b     Vector of product.
           nb    Spacing between elements of B.
           c     Result vector.
           nc    Spacing between elements of C.
           nar   Number of rows in first operand and number
                 of elements in the result.
           nbc   Number of columns in first operand and 
                 number of elements in second operand.

1 search
   A group of subroutines that perform searches for locating the number
   or positions of true occurences within a vector, for finding the first
   occurence of a target object within a vector, for finding the indices
   of all positions of an object within a vector, and for finding targets
   within ordered arrays.

2 IILZ
   A function that returns the number of zero values before the first
   nonzero value in an integer array.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IILZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 IFLZ
   A function that returns the number of zero values before the first
   nonzero value in a real array.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IFLZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 ILLZ
   A function that returns the number of false values preceding the
   first true value in a logical vector.  It returns zero if the number
   of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILLZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Logical vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 ILIZ
   A function that returns the number of positive or zero values
   preceding the first negative value in an integer vector.  It
   returns zero if the number of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILIZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 ILFZ
   A function that returns the number of positive or zero values
   preceding the first negative value in a real vector.  It returns
   zero if the number of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILFZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 ILSUM
   A function that counts the total number of true values in a vector
   declared LOGICAL.  It returns zero if the number of elements, N,
   is less than one.

       Call from FORTRAN:

             kount = ILSUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Logical vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 IISUM
   A function that counts the total number of negative values in
   a vector declared INTEGER.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IISUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 IFSUM
   A function that counts the total number of negative values in
   a vector declared REAL.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IFSUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

2 ISRCHFEQ
   A function that returns the first location in a real array that is
   equal to a real target.

       Call from FORTRAN:

             location = ISRCHFEQ(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHFNE
   A function that returns the first location in a real array that
   is not equal to a real target.

       Call from FORTRAN:

             location = ISRCHFNE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHFLT
   A function that returns the first location in a real array that is
   less than a real target.

       Call from FORTRAN:

             location = ISRCHFLT(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHFLE
   A function that returns the first location in a real array that is
   less than or equal to a real target.

       Call from FORTRAN:

             location = ISRCHFLE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHFGT
   A function that returns the first location in a real array that is
   greater than a real target.

       Call from FORTRAN:

             location = ISRCHFGT(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHFGE
   A function that returns the first location in a real array that is
   greater than or equal to a real target.

       Call from FORTRAN:

             location = ISRCHFGE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

2 ISRCHIEQ
   A function that returns the first location in an integer array that
   is equal to an integer target.

       Call from FORTRAN:

             location = ISRCHIEQ(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 ISRCHINE
   A function that returns the first location in an integer array that
   is not equal to an integer target.

       Call from FORTRAN:

             location = ISRCHINE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 ISRCHILT
   A function that returns the first location in an integer array that
   is less than an integer target.

       Call from FORTRAN:

             location = ISRCHILT(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 ISRCHILE
   A function that returns the first location in an integer array that
   is less than or equal to an integer target.

       Call from FORTRAN:

             location = ISRCHILE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 ISRCHIGT
   A function that returns the first location in an integer array that
   is greater than an integer target.

       Call from FORTRAN:

             location = ISRCHIGT(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 ISRCHIGE
   A function that returns the first location in an integer array that
   is greater than or equal to an integer target.

       Call from FORTRAN:

             location = ISRCHIGE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

2 WHENFEQ
   A subroutine that returns all locations in a real array that are
   equal to a real target.

       Call from FORTRAN:

             CALL WHENFEQ(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENFNE
   A subroutine that returns all locations in a real array that are
   not equal to a real target.

       Call from FORTRAN:

             CALL WHENFNE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENFLT
   A subroutine that returns all locations in a real array that are
   less than a real target.

       Call from FORTRAN:

             CALL WHENFLT(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENFLE
   A subroutine that returns all locations in a real array that are
   less than or equal to a real target.

       Call from FORTRAN:

             CALL WHENFLE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENFGT
   A subroutine that returns all locations in a real array that are
   greater than a real target.

       Call from FORTRAN:

             CALL WHENFGT(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENFGE
   A subroutine that returns all locations in a real array that are
   greater than or equal to a real target.

       Call from FORTRAN:

             CALL WHENFGE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENIEQ
   A subroutine that returns all locations in an integer array that are
   equal to an integer target.

       Call from FORTRAN:

             CALL WHENIEQ(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENINE
   A subroutine that returns all locations in an integer array that are
   not equal to an integer target.

       Call from FORTRAN:

             CALL WHENINE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENILT
   A subroutine that returns all locations in an integer array that are
   less than an integer target.

       Call from FORTRAN:

             CALL WHENILT(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENILE
   A subroutine that returns all locations in an integer array that are
   less than or equal to an integer target.

       Call from FORTRAN:

             CALL WHENILE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENIGT
   A subroutine that returns all locations in an integer array that are
   greater than an integer target.

       Call from FORTRAN:

             CALL WHENIGT(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 WHENIGE
   A subroutine that returns all locations in an integer array that are
   greater than or equal to an integer target.

       Call from FORTRAN:

             CALL WHENIGE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

2 OSRCHI
   A subroutine that searches an ordered integer array and returns the
   index of the first location that contains an integer target.  The
   total number of occurences of the target in the array can also be
   returned.

       Call from FORTRAN:

             CALL OSRCHI(n,iarray,inc,itarget,index,iwhere,inum)

           n        Number of elements of the array to be searched.
           iarray   Integer array to be searched.
           inc      A positive skip increment indicates an ascending
                    array and returns the index of the first element
                    encountered, starting at the beginning of array.
                    A negative skip increment indicates a descending
                    array and returns the index of the last element
                    encountered, starting at the beginning of array.
           itarget  Integer target of the search.
           index    Index of the first location in the searched array
                    that contains the target.
                    Exceptions:
                     (1) If n < 1, index = 0
                     (2) If no equal array elements, index = n+1.
           iwhere   Index of the first location in the searched array
                    that would contain the target if it were found in
                    the array (If the target is found, index=iwhere).
                    Exception:
                     if n is less than 1, iwhere=0.
           inum     Number of target elements found in the array.
                    For the total number of occurences of the target
                    in the array, this parameter must be specified
                    nonzero.

2 OSRCHF
   A subroutine that searches an ordered real array and returns the index
   of the first location that contains a real target.  The total number
   of occurences of the target in the array can also be returned.

       Call from FORTRAN:

             CALL OSRCHF(n,array,inc,target,index,iwhere,inum)

           n        Number of elements of the array to be searched.
           array    Real array to be searched.
           inc      A positive skip increment indicates an ascending
                    array and returns the index of the first element
                    encountered, starting at the beginning of array.
                    A negative skip increment indicates a descending
                    array and returns the index of the last element
                    encountered, starting at the beginning of array.
           target   Real target of the search.
           index    Index of the first location in the searched array
                    that contains the target.
                    Exceptions:
                     (1) If n < 1, index = 0
                     (2) If no equal array elements, index = n+1.
           iwhere   Index of the first location in the searched array
                    that would contain the target if it were found in
                    the array (If the target is found, index=iwhere).
                    Exception:
                         if n is less than 1, iwhere=0.
           inum     Number of target elements found in the array.
                    For the total number of occurences of the target
                    in the array, this parameter must be specified
                    nonzero.

1 ISAMAX
   An integer function that returns the index of the first occurence of the
   element in a real vector with the largest absolute value.

       Call from FORTRAN:

             index = ISAMAX(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 ICAMAX
   An integer function that returns the index of the first occurence of the
   element in a complex vector with the largest absolute value.

       Call from FORTRAN:

             index = ICAMAX(n,cx,incx)

           n     Number of elements to process in vector cx.
           cx    Complex vector to be searched.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

1 SASUM
   A real function that returns the sum of the absolute values of a real
   vector.

       Call from FORTRAN:

             sum = SASUM(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be summed.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 SCASUM
   A real function that returns the sum of the absolute values of a complex
   vector.

       Call from FORTRAN:

             csum = SCASUM(n,cx,incx)

           n     Number of elements to process in vector cx.
           cx    Complex vector to be summed.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

1 SAXPY
   A subroutine that adds a real scalar multiple of one real vector to
   another real vector.

       Call from FORTRAN:

             CALL SAXPY(n,sa,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sa    Real scalar multiplier.
           sx    Real vector.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real result vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

1 CAXPY
   A subroutine that adds a complex scalar multiple of one complex vector
   to another complex vector.

       Call from FORTRAN:

             CALL CAXPY(n,ca,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           ca    Complex scalar multiplier.
           cx    Complex vector.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex result vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

1 SCOPY
   A subroutine that copies one real vector to another.

       Call from FORTRAN:

             CALL SCOPY(n,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sx    Real vector to be copied.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real result vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

1 CCOPY
   A subroutine that copies one complex vector to another.

       Call from FORTRAN:

             CALL CCOPY(n,cx,incx,cy,incy)

           n     Number of elements in vectors.
           cx    Complex vector to be copied.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex result vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

1 SDOT
   A real function that computes the inner (dot) product of two real
   vectors.

       Call from FORTRAN:

             dot = SDOT(n,sx,incx,sy,incy)

           n     Number of elements in the vectors.
           sx    Real vector operand.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real vector operand.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

1 CDOTC
   A complex function that computes the inner (dot) product of the 
   complex conjugate of one complex vector with another complex vector.

       Call from FORTRAN:

             cdot = CDOTC(n,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           cx    Complex vector operand.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector operand.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

1 CDOTU
   A complex function that computes the inner (dot) product of two complex
   vectors.

       Call from FORTRAN:

             cdot = CDOTU(n,cx,incx,cy,incy)

           n     Number of elements in the vectors.
           cx    Complex vector operand.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector operand.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

1 SNRM2
   A real function that computes the Euclidean norm of a real vector.

       Call from FORTRAN:

             eucnorm = SNRM2(n,sx,incx)

           n     Number of elements in vector.
           sx    Real vector operand
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

       See page 4-10 of CRAY-1 Computer Systems - Library Reference Manual,
       SR-0014, for equation.

1 SCNRM2
   A real function that computes the Euclidean norm of a complex vector.

       Call from FORTRAN:

             eucnorm = SCNRM2(n,cx,incx)

           n     Number of elements in vector.
           cx    Complex vector operand
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

       See page 4-11 of CRAY-1 Computer Systems - Library Reference Manual,
       SR-0014, for equation.

1 SROTG
   A subroutine that computes the elements of a Givens rotation matrix.

       Call from FORTRAN:

             CALL SROTG(a,b,c,s)

           a     scalar supplied by user which returns the computed
                 value, r.
           b     scalar supplied by user which returns the computed
                 value, z.
           c     scalar cosine of rotation matrix (computed).
           s     scalar sine of rotation matrix (computed).

       See page 4-12 of CRAY-1 Library Reference Manual for equations.

1 SROT
   A subroutine that performs a matrix multiplication.  If the coefficients
   c and s satisfy c*c+s*s=1.0, the transformation is a Givens rotation.
   The matrix multiplication is a (2 by 2) times a (2 by n) and is used to
   modify coordinates (x,y).

       Call from FORTRAN:

             CALL SROT(n,sx,incx,sy,incy,c,s)

           n     Number of elements in vectors.
           sx    Real vector to be modified.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Real vector to be modified.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.
           c     Real cosine normally calculated using SROTG.
           s     Real sine normally calculated using SROTG.

       See page 4-13 of CRAY-1 Library Reference Manual for additional
       information.

1 SROTMG
   A subroutine that computes the elements of a modified Givens plane
   rotation matrix.

       Call from FORTRAN:
 
             CALL SROTMG(d1,d2,b1,b2,param)

           d1     Input scale factor (updated on output).
           d2     Input scale factor (updated on output).
           b1     Input scalar (updated on output).
           b2     Input scalar.
           param  A five element array containing output parameters.

       See pages 4-13 to 4-19 of CRAY-1 Library Reference Manual for
       additional information.

1 SROTM
   A subroutine that applies the modified Givens plane rotation con-
   structed by SROTMG.

       Call from FORTRAN:

             CALL SROTM(n,sx,incx,sy,incy,param)

           n      Number of elements in vectors.
           sx     Real vector.
           incx   Skip distance between elements of sx.  For contiguous
                  elements, incx = 1.
           sy     Real vector.
           incy   Skip distance between elements of sy.  For contiguous
                  elements, incy = 1.
           param  A five element array containing input parameters that
                  are normally calculated using SROTMG.

       See pages 4-19 to 4-21 of CRAY-1 Library Reference Manual for
       additional information.

1 SSCAL
   This subroutine scales a real vector by multiplying it by a real
   number.

       Call from FORTRAN:

             CALL SSCAL(n,sa,sx,incx)

           n     Number of elements in vector.
           sa    Real scaling factor.
           sx    Real vector to be scaled.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 CSSCAL
   This subroutine scales a complex vector by multiplying it by a real
   number.

       Call from FORTRAN:

             CALL CSSCAL(n,sa,cx,incx)

           n     Number of elements in vector.
           sa    Real scaling factor.
           cx    Complex vector to be scaled.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

1 CSCAL
   This subroutine scales a complex vector by multiplying it by a complex
   number.

       Call from FORTRAN:

             CALL CSCAL(n,ca,cx,incx)

           n     Number of elements in vector.
           ca    Complex scaling factor.
           cx    Complex vector to be scaled.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

1 SSWAP
   A subroutine that exchanges two real vectors.

       Call from FORTRAN:

             CALL SSWAP(n,sx,incx,sy,incy)

           n     Number of elements in vectors.
           sx    One real vector.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.
           sy    Another real vector.
           incy  Skip distance between elements of sy.  For contiguous
                 elements, incy = 1.

1 CSWAP
   A subroutine that exchanges two complex vectors.

       Call from FORTRAN:

             CALL CSWAP(n,cx,incx,cy,incy)

           n     Number of elements in vectors.
           cx    One complex vector.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Another complex vector.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.

1 SPAXPY
   A subroutine that is a useful primitive for the lower upper factor-
   ization and solution of sparse linear systems.  It is defined in
   FORTRAN in the following way:

                 DO 10 I=1,N
             10  SY(INDEX(I))=SA*SX(I)+SY(INDEX(I))

       Call from FORTRAN:

             CALL SPAXPY(n,sa,sx,sy,index)

           n      Number of elements in the vectors.
           sa     Real scalar multiplier.
           sx     Real vector operand.
           sy     Real vector operand.
           index  Vector of indexes.

1 SPDOT
   A real function that is a useful primitive for the lower upper
   factorization and solution of sparse linear systems.  It is defined
   in FORTRAN in the following way:

                 DO 10 I=1,N
             10  PDOT=PDOT+SY(INDEX(I))*SX(I)

       Call from FORTRAN:

             pdot = SPDOT(n,sy,index,sx)

           n      Number of elements in the vectors.
           sx     Real vector operand.
           sy     Real vector operand.
           index  Vector of indexes.

1 ISMAX
   An integer function that returns the first index of the largest 
   element of a real vector.

       Call from FORTRAN:

             imax = ISMAX(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 ISMIN
   An integer function that returns the first index of the smallest
   element of a real vector.

       Call from FORTRAN:

             imin = ISMIN(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 ISAMIN
   An integer function that returns the first index of the element with
   the smallest absolute value.

       Call from FORTRAN:

             imin = ISAMIN(n,sx,incx)

           n     Number of elements to process in vector sx.
           sx    Real vector to be searched.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 SSUM
   A real function that sums the elements of a real vector.

       Call from FORTRAN:

             sum = SSUM(n,sx,incx)

           n     Number of elements in vector.
           sx    Real vector to be summed.
           incx  Skip distance between elements of sx.  For contiguous
                 elements, incx = 1.

1 CSUM
   A complex function that sums the elements of a complex vector.

       Call from FORTRAN:

             sum = CSUM(n,cx,incx)

           n     Number of elements in vector.
           cx    Complex vector to be summed.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.

1 CROTG
   A subroutine that computes the elements of a complex Givens plane
   rotation matrix.

       Call from FORTRAN:

             CALL CROTG(ca,cb,cc,cs)

           ca    Complex number supplied by user which returns with a
                 computed value.
           cb    Complex number supplied by user which returns with a
                 computed value.
           cc    Complex cosine of rotation matrix (computed).
           cs    Complex sine of rotation matrix (computed).

       See page 4-28 of CRAY-1 Library Reference Manual for equation.

1 CROT
   A subroutine that applies the complex Givens plane rotation computed by
   the subroutine CROTG.

       Call from FORTRAN:

             CALL CROT(n,cx,incx,cy,incy,cc,cs)

           n     Number of elements in vectors.
           cx    Complex vector to be modified.
           incx  Skip distance between elements of cx.  For contiguous
                 elements, incx = 1.
           cy    Complex vector to be modified.
           incy  Skip distance between elements of cy.  For contiguous
                 elements, incy = 1.
           cc    Complex cosine normally calculated using CROTG.
           cs    Complex sine normally calculated using CROTG.

       See page 4-28 of CRAY-1 Library Reference Manual for equation.

1 SMACH
   A function that returns machine constants for the real limits of a
   given machine.

       Call from FORTRAN:

             x = SMACH(job)

           job = 1     The machine epsilon (the smallest number epsilon
                       such that (1. + e <> 1) and (1. - e <> 1)).
               = 2     A number close to smallest normalized, represent-
                       able number.
               = 3     A number close to largest normalized, representable
                       number.

1 CMACH
   A function that returns machine constants for the complex limits of a
   given machine.

       Call from FORTRAN:

             x = CMACH(job)

           job = 1     The machine epsilon (the smallest number epsilon
                       such that (1. + e <> 1) and (1. - e <> 1)).
               = 2     A number close to the square root of the smallest
                       normalized, representable number.
               = 3     A number close to the square root of the largest
                       normalized, representable number.

1 CFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL CFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 < 0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m for the
                 CRAY-1.
           x     Input vector.  Vector of n complex values.
           work  Working storage.  Vector of (5/2)n complex values.
           y     Result vector.  Vector of n complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, pages 4-51 to 4-52.

1 RCFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL RCFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 <=0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m.
           x     Input vector.  Vector of n real values.
           work  Working storage.  Vector of (3/2)n+2 complex values.
           y     Result vector.  Vector of (n/2)+1 complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, page 4-52.

1 CRFFT2
   A subroutine that calculates a Fourier synthesis if the sign of IX is
   negative and a Fourier analysis if the sign of IX is positive.

       Call from FORTRAN:

             CALL CRFFT2(init,ix,n,x,work,y)

           init  <>0  Generates sine and cosine tables in WORK
                 = 0  Calculates Fourier transforms using sine and
                      cosine tables of previous call.
           ix    > 0  Calculates Fourier analysis
                 <=0  Calculates Fourier synthesis.
           n     Size of Fourier transform; 2**m where 2<=m.
           x     Input vector.  Vector of (n/2)+1 complex values.
           work  Working storage.  Vector of (3/2)n+2 complex values.
           y     Result vector.  Vector of n complex values.

   For equations and other additional information, see the CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014, page 4-53.

1 FILTERG
   A subroutine that computes a convolution of two vectors.

       Call from FORTRAN:

             CALL FILTERG(a,m,d,n,o)

           a     Vector of filter coefficients.
           m     Number of filter coefficients.
           d     Input data vector.
           n     Number of data points.
           o     Output vector.

   For additional information, see pages 4-53 to 4-54 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

1 FILTERS
   A subroutine that computes the same convolution of two vectors as
   FILTERG except that it assumes the filter coefficient vector is 
   symmetric.

       Call from FORTRAN:

             CALL FILTERS(a,m,d,n,o)

           a     Symmetric filter coefficient vector.
           m     M is formally the length of vector A but 
                 because A is symmetric, only m/2 elements
                 of A are ever referenced.
           d     Input data vector.
           n     Number of data points.
           o     Output vector.

   For additional information, see pages 4-54 to 4-55 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

1 OPFILT
   A subroutine that computes the solution to the Weiner-Levinson system of
   linear equations Ta=b where T is a Toeplitz matrix in which elements are
   described by the following:

                 t(i,j)=R(k)  for abs(j-i)+1=k
                                and k=1,...,n.

       Call from FORTRAN:

             CALL OPFILT(m,a,b,c,r)

           m     Order of system of equations.
           a     Output vector of filter coefficients.
           b     Information auto-correlation vector.
           c     Scratch vector of length 2m.
           r     Signal auto-correlation vector.

   For additional information, see pages 4-55 to 4-56 of CRAY-1 Computer
   Systems - Library Reference Manual, SR-0014.

1 GATHER
   A subroutine that allows the user to gather a vector from a source
   vector as in the following way:

             A(I) = B(INDEX(I))  where I=1,N.

       Call from FORTRAN:

             CALL GATHER(n,a,b,index)

           n      Number of elements in the vectors.
           a      Output vector.
           b      Source vector.
           index  Vector of indexes.

1 SCATTER
   A subroutine that allows the user to scatter a vector into another
   vector as in the following way:

             A(INDEX(I)) = B(I)

       Call from FORTRAN:

             CALL SCATTER(n,a,index,b)

           n      Number of elements in each vector.
           a      Output vector.
           index  Vector of indexes.
           b      Source vector.

1 FOLR
   A subroutine that solves first-order linear recurrences where vector B
   is overwritten by result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = -A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula on input and vector
                 C of formula on output. (The output overwrites
                 the input.)
           incb  Skip distance between elements of the vector
                 operand B and result C.  For contiguous
                 elements, incb = 1.

1 FOLRP
   A subroutine that solves first-order linear recurrences where vector B
   is overwritten by result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLRP(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula on input and vector
                 C of formula on output. (The output overwrites
                 the input.)
           incb  Skip distance between elements of the vector
                 operand B and result C.  For contiguous
                 elements, incb = 1.

1 FOLR2
   A subroutine that solves first-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = -A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR2(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector C of above formula.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.

1 FOLR2P
   A subroutine that solves first-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              EQUIVALENCE(B,C)
              C(1) = B(1)
              DO 10 I = 2,N
           10   C(I) = A(I) * C(I-1) + B(I)

       Call from FORTRAN:

             CALL FOLR2P(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of above formula.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector C of above formula.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.

1 FOLRN
   A real function that solves for the last term of a first-order
   linear recurrence where vector B is overwritten by result C.  It
   has the form:

              DO 10 I = 2,N
           10   B(I) = -A(I) * B(I-1) + B(I)

       Call from FORTRAN:

             result = FOLRN(n,a,inca,b,incb)

           n     Length of linear recurrence.
           a     Vector A of length N of above formula.
                 (A(1) is arbitrary.)
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above formula. (The
                 output overwrites the input.)
           incb  Skip distance between elements of the vector
                 operand and result B.  For contiguous
                 elements, incb = 1.

1 SOLR
   A subroutine that solves second-order linear recurrences with input
   vectors A and B and result vector C.  It has the form:

              DO 10 I = 1,N
           10   C(I+2) = A(I) * C(I+1) + B(I) * C(I)

       Call from FORTRAN:

             CALL SOLR(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

1 SOLRN
   A real function that solves for the last term of a second-order
   linear recurrence with input vectors A and B and result vector C.
   It has the form:

              DO 10 I = 1,N
           10   C(I+2) = A(I) * C(I+1) + B(I) * C(I)

       Call from FORTRAN:

             result = SOLR(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

1 SOLR3
   A subroutine that computes a second-order linear recurrence of three
   terms.  It has input vectors A and B and result vector C, and is of
   the form:

              DO 10 I = 1,N
           10   C(I+2) = C(I+2) + A(I)*C(I+1) + B(I)*C(I)

       Call from FORTRAN:

             CALL SOLR3(n,a,inca,b,incb,c,incc)

           n     Length of linear recurrence.
           a     Vector A of length N of above equation.
           inca  Skip distance between elements of the vector
                 operand A.  For contiguous elements, inca=1.
           b     Vector B of length N of above equation.
           incb  Skip distance between elements of the vector
                 operand B.  For contiguous elements, incb=1.
           c     Vector result C of length N+2 of above equation.
           incc  Skip distance between elements of the vector
                 result C.  For contiguous elements, incc=1.
                 C(1) and C(2) are input to this routine; C(3)
                 to C(N+2) are output from this routine.

1 MINV
   A subroutine that computes the determinant and inverse of a square
   matrix and can also solve several systems of linear equations.

       Call from FORTRAN:  CALL MINV(ab,n,nd,scratch,det,eps,m,mode)

           ab      Augmented matrix of the square matrix A and the
                   n x m matrix B of the right-hand sides for each
                   system of equations to solve.  The solution over-
                   writes the corresponding right-hand side.  In the
                   calling routine, AB must be dimensioned A(nd,n+m).
           n       Order of matrix A.
           nd      Leading dimension of AB.
           scratch User-defined working storage array of length at
                   least 2*n.
           det     Determinant of matrix A.
           eps     Uuser-defined tolerance for the product of pivot
                   elements.
           m       > 0  Number of systems of linear equations to solve
                   = 0  Determinant of A is computed, depending on the
                        value of MODE.
           mode    +1   A is overwritten with A inverse
                   =0   A is not saved and A inverse is not computed.
1 MXM
   A subroutine that computes a matrix times matrix product (C=AB) and
   assumes a skip distance between elements of the matrices to be 1.

       Call from FORTRAN:

             CALL MXM(a,nar,b,nac,c,nbc)

           a     First matrix of product.
           nar   Number of rows of matrices A and C.
           b     Second matrix of product.
           nac   Number of columns of matrix A and the number of
                 rows of matrix B.
           c     Result matrix.
           nbc   Number of columns of matrices B and C.

1 MXV
   A subroutine that computes a matrix times a vector and assumes a
   skip distance between elements of the matrix to be 1.  Performs
   the following FORTRAN calculations:

                 DO 10 I = 1,NAR
              10   C(I)=A(I,1)*B(1)+A(I,2)*B(2)+...+A(I,NBR)*B(NBR)

       Call from FORTRAN:

             CALL MXV(a,nar,b,nbr,c)

           a     Matrix of product.
           nar   Number of rows of matrices A and C.
           b     Vector of product.
           nbr   Number of elements of vector B and the number
                 of columns of matrix A.
           c     Resulting vector.

1 MXMA
   A subroutine that computes a matrix times matrix product (C=AB) and
   allows for arbitrary spacing of matrix elements.

       Call from FORTRAN:

             CALL MXMA(a,na,iad,b,nb,ibd,c,nc,icd,nar,nac,nbc)

           a     First matrix of product.
           na    Spacing between column elements of A.
           iad   Spacing between row elements of A.
           b     Second matrix of product.
           nb    Spacing between column elements of B.
           ibd   Spacing between row elements of B.
           c     Output matrix.
           nc    Spacing between column elements of C.
           icd   Spacing between row elements of C.
           nar   Number of rows in first operand and result.
           nac   Number of columns in first operand and 
                 number of rows in second operand.
           nbc   Number of columns in second operand and 
                 result.

1 MXVA
   A subroutine that computes a matrix times a vector and allows for
   arbitrary spacing of matrix elements.

       Call from FORTRAN:

             CALL MXVA(a,na,iad,b,nb,c,nc,nar,nbr)

           a     Matrix of product.
           na    Spacing between column elements of A.
           iad   Spacing between row elements of A.
           b     Vector of product.
           nb    Spacing between elements of B.
           c     Result vector.
           nc    Spacing between elements of C.
           nar   Number of rows in first operand and number
                 of elements in the result.
           nbc   Number of columns in first operand and 
                 number of elements in second operand.

1 IILZ
   A function that returns the number of zero values before the first
   nonzero value in an integer array.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IILZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 IFLZ
   A function that returns the number of zero values before the first
   nonzero value in a real array.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IFLZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 ILLZ
   A function that returns the number of false values preceding the
   first true value in a logical vector.  It returns zero if the number
   of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILLZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Logical vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 ILIZ
   A function that returns the number of positive or zero values
   preceding the first negative value in an integer vector.  It
   returns zero if the number of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILIZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 ILFZ
   A function that returns the number of positive or zero values
   preceding the first negative value in a real vector.  It returns
   zero if the number of elements, N, is less than one.

       Call from FORTRAN:

             kount = ILFZ(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 ILSUM
   A function that counts the total number of true values in a vector
   declared LOGICAL.  It returns zero if the number of elements, N,
   is less than one.

       Call from FORTRAN:

             kount = ILSUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Logical vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 IISUM
   A function that counts the total number of negative values in
   a vector declared INTEGER.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IISUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Integer vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 IFSUM
   A function that counts the total number of negative values in
   a vector declared REAL.  It returns zero if the number of 
   elements, N, is less than one.

       Call from FORTRAN:

             kount = IFSUM(n,l,incl)

           n     Number of elements to process in the vector.
           l     Real vector operand.
           incl  Skip distance between elements of the vector
                 operand.  For contiguous elements, incl = 1.

1 ISRCHFEQ
   A function that returns the first location in a real array that is
   equal to a real target.

       Call from FORTRAN:

             location = ISRCHFEQ(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHFNE
   A function that returns the first location in a real array that
   is not equal to a real target.

       Call from FORTRAN:

             location = ISRCHFNE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHFLT
   A function that returns the first location in a real array that is
   less than a real target.

       Call from FORTRAN:

             location = ISRCHFLT(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHFLE
   A function that returns the first location in a real array that is
   less than or equal to a real target.

       Call from FORTRAN:

             location = ISRCHFLE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHFGT
   A function that returns the first location in a real array that is
   greater than a real target.

       Call from FORTRAN:

             location = ISRCHFGT(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHFGE
   A function that returns the first location in a real array that is
   greater than or equal to a real target.

       Call from FORTRAN:

             location = ISRCHFGE(n,array,inc,target)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.  If TARGET
                   is not found, then the returned value is n+1.

1 ISRCHIEQ
   A function that returns the first location in an integer array that
   is equal to an integer target.

       Call from FORTRAN:

             location = ISRCHIEQ(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 ISRCHINE
   A function that returns the first location in an integer array that
   is not equal to an integer target.

       Call from FORTRAN:

             location = ISRCHINE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 ISRCHILT
   A function that returns the first location in an integer array that
   is less than an integer target.

       Call from FORTRAN:

             location = ISRCHILT(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 ISRCHILE
   A function that returns the first location in an integer array that
   is less than or equal to an integer target.

       Call from FORTRAN:

             location = ISRCHILE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 ISRCHIGT
   A function that returns the first location in an integer array that
   is greater than an integer target.

       Call from FORTRAN:

             location = ISRCHIGT(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 ISRCHIGE
   A function that returns the first location in an integer array that
   is greater than or equal to an integer target.

       Call from FORTRAN:

             location = ISRCHIGE(n,iarray,inc,itarget)

           n       Number of elements to be searched.  If n <= 0,
                   then 0 is returned.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget integer value searched for in array.  If ITARGET
                   is not found, then the returned value is n+1.

1 WHENFEQ
   A subroutine that returns all locations in a real array that are
   equal to a real target.

       Call from FORTRAN:

             CALL WHENFEQ(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENFNE
   A subroutine that returns all locations in a real array that are
   not equal to a real target.

       Call from FORTRAN:

             CALL WHENFNE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENFLT
   A subroutine that returns all locations in a real array that are
   less than a real target.

       Call from FORTRAN:

             CALL WHENFLT(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENFLE
   A subroutine that returns all locations in a real array that are
   less than or equal to a real target.

       Call from FORTRAN:

             CALL WHENFLE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENFGT
   A subroutine that returns all locations in a real array that are
   greater than a real target.

       Call from FORTRAN:

             CALL WHENFGT(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENFGE
   A subroutine that returns all locations in a real array that are
   greater than or equal to a real target.

       Call from FORTRAN:

             CALL WHENFGE(n,array,inc,target,index,nval)

           n       Number of elements to be searched.
           array   Real array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           target  Real value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENIEQ
   A subroutine that returns all locations in an integer array that are
   equal to an integer target.

       Call from FORTRAN:

             CALL WHENIEQ(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENINE
   A subroutine that returns all locations in an integer array that are
   not equal to an integer target.

       Call from FORTRAN:

             CALL WHENINE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENILT
   A subroutine that returns all locations in an integer array that are
   less than an integer target.

       Call from FORTRAN:

             CALL WHENILT(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENILE
   A subroutine that returns all locations in an integer array that are
   less than or equal to an integer target.

       Call from FORTRAN:

             CALL WHENILE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENIGT
   A subroutine that returns all locations in an integer array that are
   greater than an integer target.

       Call from FORTRAN:

             CALL WHENIGT(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 WHENIGE
   A subroutine that returns all locations in an integer array that are
   greater than or equal to an integer target.

       Call from FORTRAN:

             CALL WHENIGE(n,iarray,inc,itarget,index,nval)

           n       Number of elements to be searched.
           iarray  Integer array to be searched.
           inc     Skip distance between elements of the searched
                   array.  For contiguous elements, inc = 1.
           itarget Integer value searched for in array.
           index   Integer array containing the index of the found
                   target in the array.
           nval    Number of values put in the index array.

1 OSRCHI
   A subroutine that searches an ordered integer array and returns the
   index of the first location that contains an integer target.  The
   total number of occurences of the target in the array can also be
   returned.

       Call from FORTRAN:

             CALL OSRCHI(n,iarray,inc,itarget,index,iwhere,inum)

           n        Number of elements of the array to be searched.
           iarray   Integer array to be searched.
           inc      A positive skip increment indicates an ascending
                    array and returns the index of the first element
                    encountered, starting at the beginning of array.
                    A negative skip increment indicates a descending
                    array and returns the index of the last element
                    encountered, starting at the beginning of array.
           itarget  Integer target of the search.
           index    Index of the first location in the searched array
                    that contains the target.
                    Exceptions:
                     (1) If n < 1, index = 0
                     (2) If no equal array elements, index = n+1.
           iwhere   Index of the first location in the searched array
                    that would contain the target if it were found in
                    the array (If the target is found, index=iwhere).
                    Exception:
                     if n is less than 1, iwhere=0.
           inum     Number of target elements found in the array.
                    For the total number of occurences of the target
                    in the array, this parameter must be specified
                    nonzero.

1 OSRCHF
   A subroutine that searches an ordered real array and returns the index
   of the first location that contains a real target.  The total number
   of occurences of the target in the array can also be returned.

       Call from FORTRAN:

             CALL OSRCHF(n,array,inc,target,index,iwhere,inum)

           n        Number of elements of the array to be searched.
           array    Real array to be searched.
           inc      A positive skip increment indicates an ascending
                    array and returns the index of the first element
                    encountered, starting at the beginning of array.
                    A negative skip increment indicates a descending
                    array and returns the index of the last element
                    encountered, starting at the beginning of array.
           target   Real target of the search.
           index    Index of the first location in the searched array
                    that contains the target.
                    Exceptions:
                     (1) If n < 1, index = 0
                     (2) If no equal array elements, index = n+1.
           iwhere   Index of the first location in the searched array
                    that would contain the target if it were found in
                    the array (If the target is found, index=iwhere).
                    Exception:
                         if n is less than 1, iwhere=0.
           inum     Number of target elements found in the array.
                    For the total number of occurences of the target
                    in the array, this parameter must be specified
                    nonzero.

1 LINPACK
   LINPACK is a package of FORTRAN routines that solve systems of
   linear equations and compute the QR, Cholesky, and singular value
   decompositions. The original FORTRAN programs are documented in
   the

         LINPACK User's Guide;  J.J. Dongarra, C.B. Moler,
            J.R. Bunch, and G.W. Stewart; Society for
            Industrial and Applied Mathematics, Philadelphia,
            1979.

1 EISPACK
   EISPACK is a package of FORTRAN routines for solving the eigen-
   value problem, computing and using the singular value decomposi-
   tion, and solving banded symmetric systems of linear equations.
   The original FORTRAN versions are documented in the

         Matrix Eigensystem Routines - EISPACK Guide, second
            edition; B.T. Smith, J.M. Boyle, J.J. Dongarra,
            B.S. Garbow, Y. Ikebe, V.C. Klema, C.B. Moler;
            Springer-Verlag, New York, 1977.

.
