!
!     MATHS.FI	- Declare single-precision MS IMSL MATH/LIBRARY routines
!
!     For use with the MS IMSL Libraries for MS FORTRAN PowerStation
!     for DOS and MS IMSL Libraries for MS FORTRAN PowerStation 32
!
!     Copyright (c) 1994 by Visual Numerics, Inc.  All Rights Reserved.
!
!     NOTE:  The following rules are followed to maintain compatibility
!            with fixed-form and free-form source:
!            1. All comments must start with '!'
!            2. All code must be within columns 7-72
!            3. For continuation, a '&' is in column 73 of the line to
!               be continued and in column 6 of the continuation line
!

$IF .NOT. DEFINED (IMSL_MATH_SINGLE)

!
!     Chapter 1:  Linear Systems
!

      interface to subroutine lsarg (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2arg (n, a, lda, b, ipath, x, fac, ipvt, &
     &           wk)
      integer    n, lda, ipath, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfcrg (n, a, lda, fac, ldfac, ipvt, rcond)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond, a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2crg (n, a, lda, fac, ldfac, ipvt, rcond,&
     &           z)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond, a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lfirg (n, a, lda, fac, ldfac, ipvt, b,    &
     &           ipath, x, res)
      integer    n, lda, ldfac, ipath, ipvt(*)
      real       a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lsacg (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2acg (n, a, lda, b, ipath, x, fac, ipvt, &
     &           wk)
      integer    n, lda, ipath, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslcg (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lcg (n, a, lda, b, ipath, x, fac, ipvt, &
     &           wk)
      integer    n, lda, ipath, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfccg (n, a, lda, fac, ldfac, ipvt, rcond)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2ccg (n, a, lda, fac, ldfac, ipvt, rcond,&
     &           z)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftcg (n, a, lda, fac, ldfac, ipvt)
      integer    n, lda, ldfac, ipvt(*)
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2tcg (n, a, lda, fac, ldfac, ipvt, scale)
      integer    n, lda, ldfac, ipvt(n)
      complex    a(lda,*), fac(ldfac,*), scale(*)
      end

      interface to subroutine lfscg (n, fac, ldfac, ipvt, b, ipath, x)
      integer    n, ldfac, ipath, ipvt(*)
      complex    fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lficg (n, a, lda, fac, ldfac, ipvt, b,    &
     &           ipath, x, res)
      integer    n, lda, ldfac, ipath, ipvt(*)
      complex    a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdcg (n, fac, ldfac, ipvt, det1, det2)
      integer    n, ldfac, ipvt(*)
      real       det2
      complex    det1, fac(ldfac,*)
      end

      interface to subroutine lincg (n, a, lda, ainv, ldainv)
      integer    n, lda, ldainv
      complex    a(lda,*), ainv(ldainv,*)
      end

      interface to subroutine l2ncg (n, a, lda, ainv, ldainv, wk, iwk)
      integer    n, lda, ldainv, iwk(*)
      complex    a(lda,*), ainv(ldainv,*), wk(*)
      end

      interface to subroutine lslrt (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine lfcrt (n, a, lda, ipath, rcond)
      integer    n, lda, ipath
      real       rcond, a(lda,*)
      end

      interface to subroutine l2crt (n, a, lda, ipath, rcond, z)
      integer    n, lda, ipath
      real       rcond, a(lda,*), z(*)
      end

      interface to subroutine lfdrt (n, a, lda, det1, det2)
      integer    n, lda
      real       det1, det2, a(lda,*)
      end

      interface to subroutine linrt (n, a, lda, ipath, ainv, ldainv)
      integer    n, lda, ipath, ldainv
      real       a(lda,*), ainv(ldainv,*)
      end

      interface to subroutine lslct (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine lfcct (n, a, lda, ipath, rcond)
      integer    n, lda, ipath
      real       rcond
      complex    a(lda,*)
      end

      interface to subroutine l2cct (n, a, lda, ipath, rcond, z)
      integer    n, lda, ipath
      real       rcond
      complex    a(lda,*), z(*)
      end

      interface to subroutine lfdct (n, a, lda, det1, det2)
      integer    n, lda
      real       det2
      complex    det1, a(lda,*)
      end

      interface to subroutine linct (n, a, lda, ipath, ainv, ldainv)
      integer    n, lda, ipath, ldainv
      complex    a(lda,*), ainv(ldainv,*)
      end

      interface to subroutine lsads (n, a, lda, b, x)
      integer    n, lda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2ads (n, a, lda, b, x, fac, wk)
      integer    n, lda
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslds (n, a, lda, b, x)
      integer    n, lda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lds (n, a, lda, b, x, fac, wk)
      integer    n, lda
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfcds (n, a, lda, fac, ldfac, rcond)
      integer    n, lda, ldfac
      real       rcond, a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2cds (n, a, lda, fac, ldfac, rcond, z)
      integer    n, lda, ldfac
      real       rcond, a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftds (n, a, lda, fac, ldfac)
      integer    n, lda, ldfac
      real       a(lda,*), fac(ldfac,*)
      end

      interface to subroutine lfsds (n, fac, ldfac, b, x)
      integer    n, ldfac
      real       fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfids (n, a, lda, fac, ldfac, b, x, res)
      integer    n, lda, ldfac
      real       a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdds (n, fac, ldfac, det1, det2)
      integer    n, ldfac
      real       det1, det2, fac(ldfac,*)
      end

      interface to subroutine linds (n, a, lda, ainv, ldainv)
      integer    n, lda, ldainv
      real       a(lda,*), ainv(ldainv,*)
      end

      interface to subroutine l2nds (n, a, lda, ainv, ldainv, wk)
      integer    n, lda, ldainv
      real       a(lda,*), ainv(ldainv,*), wk(*)
      end

      interface to subroutine lsasf (n, a, lda, b, x)
      integer    n, lda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2asf (n, a, lda, b, x, fac, ipvt, wk)
      integer    n, lda, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslsf (n, a, lda, b, x)
      integer    n, lda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lsf (n, a, lda, b, x, fac, ipvt, wk)
      integer    n, lda, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfcsf (n, a, lda, fac, ldfac, ipvt, rcond)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond, a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2csf (n, a, lda, fac, ldfac, ipvt, rcond,&
     &           z)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond, a(*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftsf (n, a, lda, fac, ldfac, ipvt)
      integer    n, lda, ldfac, ipvt(*)
      real       a(*), fac(ldfac,*)
      end

      interface to subroutine lfssf (n, fac, ldfac, ipvt, b, x)
      integer    n, ldfac, ipvt(*)
      real       fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfisf (n, a, lda, fac, ldfac, ipvt, b, x, &
     &           res)
      integer    n, lda, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdsf (n, fac, ldfac, ipvt, det1, det2)
      integer    n, ldfac, ipvt(*)
      real       det1, det2, fac(ldfac,*)
      end

      interface to subroutine lsadh (n, a, lda, b, x)
      integer    n, lda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2adh (n, a, lda, b, x, fac, wk)
      integer    n, lda
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lsldh (n, a, lda, b, x)
      integer    n, lda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2ldh (n, a, lda, b, x, fac, wk)
      integer    n, lda
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfcdh (n, a, lda, fac, ldfac, rcond)
      integer    n, lda, ldfac
      real       rcond
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2cdh (n, a, lda, fac, ldfac, rcond, z)
      integer    n, lda, ldfac
      real       rcond
      complex    a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftdh (n, a, lda, fac, ldfac)
      integer    n, lda, ldfac
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine lfsdh (n, fac, ldfac, b, x)
      integer    n, ldfac
      complex    fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfidh (n, a, lda, fac, ldfac, b, x, res)
      integer    n, lda, ldfac
      complex    a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfddh (n, fac, ldfac, det1, det2)
      integer    n, ldfac
      real       det1, det2
      complex    fac(ldfac,*)
      end

      interface to subroutine lsahf (n, a, lda, b, x)
      integer    n, lda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2ahf (n, a, lda, b, x, fac, ipvt, wk)
      integer    n, lda, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslhf (n, a, lda, b, x)
      integer    n, lda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lhf (n, a, lda, b, x, fac, ipvt, wk)
      integer    n, lda, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfchf (n, a, lda, fac, ldfac, ipvt, rcond)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2chf (n, a, lda, fac, ldfac, ipvt, rcond,&
     &           z)
      integer    n, lda, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lfthf (n, a, lda, fac, ldfac, ipvt)
      integer    n, lda, ldfac, ipvt(*)
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine lfshf (n, fac, ldfac, ipvt, b, x)
      integer    n, ldfac, ipvt(*)
      complex    fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfihf (n, a, lda, fac, ldfac, ipvt, b, x, &
     &           res)
      integer    n, lda, ldfac, ipvt(*)
      complex    a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdhf (n, fac, ldfac, ipvt, det1, det2)
      integer    n, ldfac, ipvt(*)
      real       det1, det2
      complex    fac(ldfac,*)
      end

      interface to subroutine lsltr (n, c, d, e, b)
      integer    n
      real       c(*), d(*), e(*), b(*)
      end

      interface to subroutine lslcr (n, c, a, b, ijob, y, u, ir, is)
      integer    n, ijob
      real       c(*), a(*), b(*), y(*), u(*)
      end

      interface to subroutine lsarb (n, a, lda, nlca, nuca, b, ipath, x)
      integer    n, lda, nlca, nuca, ipath
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2arb (n, a, lda, nlca, nuca, b, ipath, x,&
     &           fac, ipvt, wk)
      integer    n, lda, nlca, nuca, ipath, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslrb (n, a, lda, nlca, nuca, b, ipath, x)
      integer    n, lda, nlca, nuca, ipath
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lrb (n, a, lda, nlca, nuca, b, ipath, x,&
     &           fac, ipvt, wk)
      integer    n, lda, nlca, nuca, ipath, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfcrb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, rcond)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       rcond, a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2crb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, rcond, z)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       rcond, a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftrb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2trb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, scale)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*), scale(*)
      end

      interface to subroutine lfsrb (n, fac, ldfac, nlca, nuca, ipvt, b,&
     &           ipath, x)
      integer    n, ldfac, nlca, nuca, ipath, ipvt(*)
      real       fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfirb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, b, ipath, x, res)
      integer    n, lda, nlca, nuca, ldfac, ipath, ipvt(*)
      real       a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdrb (n, fac, ldfac, nlca, nuca, ipvt,   &
     &           det1, det2)
      integer    n, ldfac, nlca, nuca, ipvt(*)
      real       det1, det2, fac(ldfac,*)
      end

      interface to subroutine lsaqs (n, a, lda, ncoda, b, x)
      integer    n, lda, ncoda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2aqs (n, a, lda, ncoda, b, x, fac, wk)
      integer    n, lda, ncoda
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslqs (n, a, lda, ncoda, b, x)
      integer    n, lda, ncoda
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lqs (n, a, lda, ncoda, b, x, fac, wk)
      integer    n, lda, ncoda
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslpb (n, a, lda, ncoda, ijob, u)
      integer    n, lda, ncoda, ijob
      real       a(-ncoda+1:lda-ncoda,*), u(*)
      end

      interface to subroutine l2lpb (n, a, lda, ncoda, ijob, u, w)
      integer    lda, n, ncoda, ijob
      real       a(-ncoda+1:lda-ncoda,*), u(*), w(*)
      end

      interface to subroutine lfcqs (n, a, lda, ncoda, fac, ldfac,      &
     &           rcond)
      integer    n, lda, ncoda, ldfac
      real       rcond, a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2cqs (n, a, lda, ncoda, fac, ldfac,      &
     &           rcond, z)
      integer    n, lda, ncoda, ldfac
      real       rcond, a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftqs (n, a, lda, ncoda, fac, ldfac)
      integer    n, lda, ncoda, ldfac
      real       a(lda,*), fac(ldfac,*)
      end

      interface to subroutine lfsqs (n, fac, ldfac, ncoda, b, x)
      integer    n, ldfac, ncoda
      real       fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfiqs (n, a, lda, ncoda, fac, ldfac, b, x,&
     &           res)
      integer    n, lda, ncoda, ldfac
      real       a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdqs (n, fac, ldfac, ncoda, det1, det2)
      integer    n, ldfac, ncoda
      real       det1, det2, fac(ldfac,*)
      end

      interface to subroutine lsltq (n, c, d, e, b)
      integer    n
      complex    c(*), d(*), e(*), b(*)
      end

      interface to subroutine lslcq (n, c, a, b, ijob, y, u, ir, is)
      integer    n, ijob
      real       u(*)
      complex    c(*), a(*), b(*), y(*)
      end

      interface to subroutine lsacb (n, a, lda, nlca, nuca, b, ipath, x)
      integer    n, lda, nlca, nuca, ipath
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2acb (n, a, lda, nlca, nuca, b, ipath, x,&
     &           fac, ipvt, wk)
      integer    n, lda, nlca, nuca, ipath, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslcb (n, a, lda, nlca, nuca, b, ipath, x)
      integer    n, lda, nlca, nuca, ipath
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lcb (n, a, lda, nlca, nuca, b, ipath, x,&
     &           fac, ipvt, wk)
      integer    n, lda, nlca, nuca, ipath, ipvt(*)
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lfccb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, rcond)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2ccb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, rcond, z)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      real       rcond
      complex    a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftcb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2tcb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, scale)
      integer    n, lda, nlca, nuca, ldfac, ipvt(*)
      complex    a(lda,*), fac(ldfac,*), scale(*)
      end

      interface to subroutine lfscb (n, fac, ldfac, nlca, nuca, ipvt, b,&
     &           ipath, x)
      integer    n, ldfac, nlca, nuca, ipath, ipvt(*)
      complex    fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lficb (n, a, lda, nlca, nuca, fac, ldfac, &
     &           ipvt, b, ipath, x, res)
      integer    n, lda, nlca, nuca, ldfac, ipath, ipvt(*)
      complex    a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdcb (n, fac, ldfac, nlca, nuca, ipvt,   &
     &           det1, det2)
      integer    n, ldfac, nlca, nuca, ipvt(*)
      real       det2
      complex    det1, fac(ldfac,*)
      end

      interface to subroutine lsaqh (n, a, lda, ncoda, b, x)
      integer    n, lda, ncoda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2aqh (n, a, lda, ncoda, b, x, fac, wk)
      integer    n, lda, ncoda
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslqh (n, a, lda, ncoda, b, x)
      integer    n, lda, ncoda
      complex    a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lqh (n, a, lda, ncoda, b, x, fac, wk)
      integer    n, lda, ncoda
      complex    a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lslqb (n, a, lda, ncoda, ijob, u)
      integer    n, lda, ncoda, ijob
      real       a(-ncoda+1:lda-ncoda,*), u(*)
      end

      interface to subroutine l2lqb (n, a, lda, ncoda, ijob, u, x, y)
      integer    lda, n, ncoda, ijob
      real       a(-ncoda+1:lda-ncoda,*), u(*), x(*), y(*)
      end

      interface to subroutine lfcqh (n, a, lda, ncoda, fac, ldfac,      &
     &           rcond)
      integer    n, lda, ncoda, ldfac
      real       rcond
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2cqh (n, a, lda, ncoda, fac, ldfac,      &
     &           rcond, z)
      integer    n, lda, ncoda, ldfac
      real       rcond
      complex    a(lda,*), fac(ldfac,*), z(*)
      end

      interface to subroutine lftqh (n, a, lda, ncoda, fac, ldfac)
      integer    n, lda, ncoda, ldfac
      complex    a(lda,*), fac(ldfac,*)
      end

      interface to subroutine lfsqh (n, fac, ldfac, ncoda, b, x)
      integer    n, ldfac, ncoda
      complex    fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfiqh (n, a, lda, ncoda, fac, ldfac, b, x,&
     &           res)
      integer    n, lda, ncoda, ldfac
      complex    a(lda,*), fac(ldfac,*), b(*), x(*), res(*)
      end

      interface to subroutine lfdqh (n, fac, ldfac, ncoda, det1, det2)
      integer    n, ldfac, ncoda
      real       det1, det2
      complex    fac(ldfac,*)
      end

      interface to subroutine lslxg (n, nz, a, irow, jcol, b, ipath,    &
     &           iparam, rparam, x)
      integer    n, nz, ipath, irow(*), jcol(*), iparam(*)
      real       a(*), b(*), rparam(*), x(*)
      end

      interface to subroutine l2lxg (n, nz, a, irow, jcol, b, ipath,    &
     &           iparam, rparam, x, wk, lwk, iwk, liwk)
      integer    n, nz, ipath, lwk, liwk, irow(*), jcol(*), iparam(*),  &
     &           iwk(*)
      real       a(*), b(*), rparam(*), x(*), wk(lwk)
      end

      interface to subroutine l4lxg (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

      interface to subroutine lftxg (n, nz, a, irow, jcol, iparam,      &
     &           rparam, nfac, nl, fac, irfac, jcfac, ipvt, jpvt)
      integer    n, nz, nfac, nl, irow(*), jcol(*), iparam(*),          &
     &           irfac(*), jcfac(*), ipvt(*), jpvt(*)
      real       a(*), rparam(*), fac(*)
      end

      interface to subroutine l2txg (n, nz, a, irow, jcol, iparam,      &
     &           rparam, nfac, nl, fac, irfac, jcfac, ipvt, jpvt, wk,   &
     &           lwk, iwk, liwk)
      integer    n, nz, nfac, nl, lwk, liwk, irow(*), jcol(*),          &
     &           iparam(*), irfac(*), jcfac(*), ipvt(*), jpvt(*),       &
     &           iwk(*)
      real       a(*), rparam(*), fac(*), wk(*)
      end

      interface to subroutine lfsxg (n, nfac, nl, fac, irfac, jcfac,    &
     &           ipvt, jpvt, b, ipath, x)
      integer    n, nfac, nl, ipath, irfac(*), jcfac(*), ipvt(*),       &
     &           jpvt(*)
      real       fac(*), b(*), x(*)
      end

      interface to subroutine lslzg (n, nz, a, irow, jcol, b, ipath,    &
     &           iparam, rparam, x)
      integer    n, nz, ipath, irow(*), jcol(*), iparam(*)
      real       rparam(*)
      complex    a(*), b(*), x(*)
      end

      interface to subroutine l2lzg (n, nz, a, irow, jcol, b, ipath,    &
     &           iparam, rparam, x, wk, lwk, iwk, liwk)
      integer    n, nz, ipath, lwk, liwk, irow(*), jcol(*), iparam(*),  &
     &           iwk(*)
      real       rparam(*)
      complex    a(*), b(*), x(*), wk(*)
      end

      interface to subroutine l4lzg (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

      interface to subroutine lftzg (n, nz, a, irow, jcol, iparam,      &
     &           rparam, nfac, nl, fac, irfac, jcfac, ipvt, jpvt)
      integer    n, nz, nfac, nl, irow(*), jcol(*), iparam(*),          &
     &           irfac(*), jcfac(*), ipvt(*), jpvt(*)
      real       rparam(*)
      complex    a(*), fac(*)
      end

      interface to subroutine l2tzg (n, nz, a, irow, jcol, iparam,      &
     &           rparam, nfac, nl, fac, irfac, jcfac, ipvt, jpvt, wk,   &
     &           lwk, iwk, liwk)
      integer    n, nz, nfac, nl, lwk, liwk, irow(*), jcol(*),          &
     &           iparam(*), irfac(*), jcfac(*), ipvt(*), jpvt(*),       &
     &           iwk(*)
      real       rparam(*)
      complex    a(*), fac(*), wk(*)
      end

      interface to subroutine lfszg (n, nfac, nl, fac, irfac, jcfac,    &
     &           ipvt, jpvt, b, ipath, x)
      integer    n, nfac, nl, ipath, irfac(*), jcfac(*), ipvt(*),       &
     &           jpvt(*)
      complex    fac(*), b(*), x(*)
      end

      interface to subroutine lslxd (n, nz, a, irow, jcol, b, itwksp, x)
      integer    n, nz, itwksp, irow(*), jcol(*)
      real       a(*), b(*), x(*)
      end

      interface to subroutine l2lxd (n, nz, a, irow, jcol, b, x, iper,  &
     &           iparam, rparam, wk, lwk, iwk, liwk)
      integer    n, nz, lwk, liwk, irow(*), jcol(*), iper(*),           &
     &           iparam(*), iwk(*)
      real       a(*), b(*), x(*), rparam(*), wk(*)
      end

      interface to subroutine l4lxd (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

      interface to subroutine lscxd (n, nz, irow, jcol, ijob, itwksp,   &
     &           maxsub, nzsub, inzsub, maxnz, ilnz, iper, invper,      &
     &           ispace)
      integer    n, nz, ijob, itwksp, maxsub, maxnz, ispace, irow(*),   &
     &           jcol(*), nzsub(*), inzsub(*), ilnz(*), iper(*),        &
     &           invper(*)
      end

      interface to subroutine l2cxd (n, nz, irow, jcol, ijob, maxsub,   &
     &           nzsub, inzsub, maxnz, ilnz, iper, invper, ispace, liwk,&
     &           iwk)
      integer    n, nz, ijob, maxsub, maxnz, ispace, liwk, irow(*),     &
     &           jcol(*), nzsub(*), inzsub(*), ilnz(*), iper(*),        &
     &           invper(*), iwk(*)
      end

      interface to subroutine lnfxd (n, nz, a, irow, jcol, ijob, maxsub,&
     &           nzsub, inzsub, maxnz, ilnz, iper, invper, ispace,      &
     &           itwksp, diag, rlnz, rparam)
      integer    n, nz, ijob, maxsub, maxnz, ispace, itwksp, irow(*),   &
     &           jcol(*), nzsub(*), inzsub(*), ilnz(*), iper(*),        &
     &           invper(*)
      real       a(*), diag(*), rlnz(*), rparam(*)
      end

      interface to subroutine l2fxd (n, nz, a, irow, jcol, ijob, maxsub,&
     &           nzsub, inzsub, maxnz, ilnz, iper, invper, ispace, diag,&
     &           rlnz, rparam, wk, lwk, iwk, liwk)
      integer    n, nz, ijob, maxsub, maxnz, ispace, lwk, liwk,         &
     &           irow(*), jcol(*), nzsub(*), inzsub(*), ilnz(*),        &
     &           iper(*), invper(*), iwk(*)
      real       a(*), diag(*), rlnz(*), rparam(*), wk(*)
      end

      interface to subroutine lfsxd (n, maxsub, nzsub, inzsub, maxnz,   &
     &           rlnz, ilnz, diag, iper, b, x)
      integer    n, maxsub, maxnz, nzsub(*), inzsub(*), ilnz(*),        &
     &           iper(*)
      real       rlnz(*), diag(*), b(*), x(*)
      end

      interface to subroutine lslzd (n, nz, a, irow, jcol, b, itwksp, x)
      integer    n, nz, itwksp, irow(*), jcol(*)
      complex    a(*), b(*), x(*)
      end

      interface to subroutine l2lzd (n, nz, a, irow, jcol, b, x, iper,  &
     &           iparam, rparam, wk, lwk, iwk, liwk)
      integer    n, nz, lwk, liwk, irow(*), jcol(*), iper(*),           &
     &           iparam(*), iwk(*)
      real       rparam(*)
      complex    a(*), b(*), x(*), wk(*)
      end

      interface to subroutine l4lzd (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

      interface to subroutine lnfzd (n, nz, a, irow, jcol, ijob, maxsub,&
     &           nzsub, inzsub, maxnz, ilnz, iper, invper, ispace,      &
     &           itwksp, diag, rlnz, rparam)
      integer    n, nz, ijob, maxsub, maxnz, ispace, itwksp, irow(*),   &
     &           jcol(*), nzsub(*), inzsub(*), ilnz(*), iper(*),        &
     &           invper(*)
      real       rparam(*)
      complex    a(*), diag(*), rlnz(*)
      end

      interface to subroutine l2fzd (n, nz, a, irow, jcol, ijob, maxsub,&
     &           nzsub, inzsub, maxnz, ilnz, iper, invper, ispace, diag,&
     &           rlnz, rparam, wk, lwk, iwk, liwk)
      integer    n, nz, ijob, maxsub, maxnz, ispace, lwk, liwk,         &
     &           irow(*), jcol(*), nzsub(*), inzsub(*), ilnz(*),        &
     &           iper(*), invper(*), iwk(*)
      real       rparam(*)
      complex    a(*), diag(*), rlnz(*), wk(*)
      end

      interface to subroutine lfszd (n, maxsub, nzsub, inzsub, maxnz,   &
     &           rlnz, ilnz, diag, iper, b, x)
      integer    n, maxsub, maxnz, nzsub(*), inzsub(*), ilnz(*),        &
     &           iper(*)
      complex    rlnz(*), diag(*), b(*), x(*)
      end

      interface to subroutine lslto (n, a, b, ipath, x)
      integer    n, ipath
      real       a(*), b(*), x(*)
      end

      interface to subroutine l2lto (n, a, b, ipath, x, wk)
      integer    n, ipath
      real       a(*), b(*), x(*), wk(*)
      end

      interface to subroutine lsltc (n, a, b, ipath, x)
      integer    n, ipath
      complex    a(*), b(*), x(*)
      end

      interface to subroutine l2ltc (n, a, b, ipath, x, wk)
      integer    n, ipath
      complex    a(*), b(*), x(*), wk(*)
      end

      interface to subroutine lslcc (n, a, b, ipath, x)
      integer    n, ipath
      complex    a(*), b(*), x(*)
      end

      interface to subroutine l2lcc (n, a, b, ipath, x, ahat, wk)
      integer    n, ipath
      real       wk(*)
      complex    a(*), b(*), x(*), ahat(*)
      end

      interface to subroutine pcgrc (ido, n, x, p, r, z, relerr, itmax)
      integer    ido, n, itmax
      real       relerr, x(*), p(*), r(*), z(*)
      end

      interface to subroutine p2grc (ido, n, x, p, r, z, relerr, itmax, &
     &           tri, work, iwork)
      integer    ido, n, itmax, iwork(*)
      real       relerr, x(*), p(*), r(*), z(*), tri(2,*), work(*)
      end

      interface to subroutine jcgrc (ido, n, diag, x, p, r, z, relerr,  &
     &           itmax)
      integer    ido, n, itmax
      real       relerr, diag(*), x(*), p(*), r(*), z(*)
      end

      interface to subroutine j2grc (ido, n, diag, x, p, r, z, relerr,  &
     &           itmax, tri, work, iwork)
      integer    ido, n, itmax, iwork(*)
      real       relerr, diag(*), x(*), p(*), r(*), z(*), tri(2,*),     &
     &           work(*)
      end

      interface to subroutine lqrrv (nra, nca, numexc, a, lda, x, ldx)
      integer    nra, nca, numexc, lda, ldx
      real       a(lda,*), x(ldx,*)
      end

      interface to subroutine l2rrv (nra, nca, numexc, a, lda, x, ldx,  &
     &           fac, ldfac, work)
      integer    nra, nca, numexc, lda, ldx, ldfac
      real       a(lda,*), x(ldx,*), fac(ldfac,*), work(nca+numexc+1,*)
      end

      interface to subroutine lclsq (nra, nca, ncon, a, lda, b, c, ldc, &
     &           bl, bu, irtype, xlb, xub, x, res)
      integer    nra, nca, ncon, lda, ldc, irtype(*)
      real       a(lda,*), b(*), c(ldc,*), bl(*), bu(*), xlb(*),        &
     &           xub(*), x(*), res(*)
      end

      interface to subroutine l2lsq (nra, nca, ncon, a, lda, b, c, ldc, &
     &           bl, bu, irtype, xlb, xub, x, res, wk, iwk)
      integer    nra, nca, ncon, lda, ldc, irtype(*), iwk(*)
      real       a(lda,*), b(*), c(ldc,*), bl(*), bu(*), xlb(*),        &
     &           xub(*), x(*), res(*), wk(*)
      end

      interface to subroutine lqrrr (nra, nca, a, lda, pivot, ipvt, qr, &
     &           ldqr, qraux, conorm)
      integer    nra, nca, lda, ldqr, ipvt(*)
      real       a(*), qr(*), qraux(*), conorm(*)
      logical    pivot
      end

      interface to subroutine l2rrr (nra, nca, a, lda, pivot, ipvt, qr, &
     &           ldqr, qraux, conorm, work)
      integer    nra, nca, lda, ldqr, ipvt(*)
      real       a(lda,*), qr(ldqr,*), qraux(*), conorm(*), work(*)
      logical    pivot
      end

      interface to subroutine lqerr (nrqr, ncqr, qr, ldqr, qraux, q,    &
     &           ldq)
      integer    nrqr, ncqr, ldqr, ldq
      real       qr(ldqr,*), qraux(*), q(ldq,*)
      end

      interface to subroutine l2err (nrqr, ncqr, qr, ldqr, qraux, q,    &
     &           ldq, work)
      integer    nrqr, ncqr, ldqr, ldq
      real       qr(ldqr,*), qraux(*), q(ldq,*), work(*)
      end

      interface to subroutine lqrsl (nra, kbasis, qr, ldqr, qraux, b,   &
     &           ipath, qb, qtb, x, res, ab)
      integer    nra, kbasis, ldqr, ipath
      real       qr(ldqr,*), qraux(*), b(*), qb(*), qtb(*), x(*),       &
     &           res(*), ab(*)
      end

      interface to subroutine lupqr (nrow, ncol, alpha, w, y, q, ldq, r,&
     &           ldr, ipath, qnew, ldqnew, rnew, ldrnew)
      integer    nrow, ncol, ldq, ldr, ipath, ldqnew, ldrnew
      real       alpha, w(*), y(*), q(*), r(*), qnew(*), rnew(*)
      end

      interface to subroutine l2pqr (nrow, ncol, alpha, w, y, q, ldq, r,&
     &           ldr, ipath, qnew, ldqnew, rnew, ldrnew, z, work)
      integer    nrow, ncol, ldq, ldr, ipath, ldqnew, ldrnew
      real       alpha, w(*), y(*), q(ldq,*), r(ldr,*),                 &
     &           qnew(ldqnew,*), rnew(ldrnew,*), z(*), work(*)
      end

      interface to subroutine lchrg (n, a, lda, pivot, ipvt, fac, ldfac)
      integer    n, lda, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*)
      logical    pivot
      end

      interface to subroutine lupch (n, r, ldr, x, rnew, ldrnew, cs, sn)
      integer    n, ldr, ldrnew
      real       r(ldr,*), x(*), rnew(ldrnew,*), cs(*), sn(*)
      end

      interface to subroutine ldnch (n, r, ldr, x, rnew, ldrnew, cs, sn)
      integer    n, ldr, ldrnew
      real       r(ldr,*), x(*), rnew(ldrnew,*), cs(*), sn(*)
      end

      interface to subroutine lsvcr (nra, nca, a, lda, ipath, tol,      &
     &           irank, s, u, ldu, v, ldv)
      integer    nra, nca, lda, ipath, irank, ldu, ldv
      real       tol
      complex    a(lda,*), s(*), u(ldu,*), v(ldv,*)
      end

      interface to subroutine l2vcr (nra, nca, a, lda, ipath, tol,      &
     &           irank, s, u, ldu, v, ldv, wka, wk)
      integer    nra, nca, lda, ipath, irank, ldu, ldv
      real       tol
      complex    a(lda,*), s(*), u(*), v(*), wka(*), wk(*)
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine lslrg (n, a, lda, b, ipath, x)
      integer    n, lda, ipath
      real       a(lda,*), b(*), x(*)
      end

      interface to subroutine l2lrg (n, a, lda, b, ipath, x, fac, ipvt, &
     &           wk)
      integer    n, lda, ipath, ipvt(*)
      real       a(lda,*), b(*), x(*), fac(*), wk(*)
      end

      interface to subroutine lftrg (n, a, lda, fac, ldfac, ipvt)
      integer    n, lda, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*)
      end

      interface to subroutine l2trg (n, a, lda, fac, ldfac, ipvt, scale)
      integer    n, lda, ldfac, ipvt(*)
      real       a(lda,*), fac(ldfac,*), scale(*)
      end

      interface to subroutine lfsrg (n, fac, ldfac, ipvt, b, ipath, x)
      integer    n, ldfac, ipath, ipvt(*)
      real       fac(ldfac,*), b(*), x(*)
      end

      interface to subroutine lfdrg (n, fac, ldfac, ipvt, det1, det2)
      integer    n, ldfac, ipvt(*)
      real       det1, det2, fac(ldfac,*)
      end

      interface to subroutine linrg (n, a, lda, ainv, ldainv)
      integer    n, lda, ldainv
      real       a(lda,*), ainv(ldainv,*)
      end

      interface to subroutine l2nrg (n, a, lda, ainv, ldainv, wk, iwk)
      integer    n, lda, ldainv, iwk(*)
      real       a(lda,*), ainv(ldainv,*), wk(*)
      end

      interface to subroutine lsqrr (nra, nca, a, lda, b, tol, x, res,  &
     &           kbasis)
      integer    nra, nca, lda, kbasis
      real       tol, a(*), b(*), x(*), res(*)
      end

      interface to subroutine l2qrr (nra, nca, a, lda, b, tol, x, res,  &
     &           kbasis, qr, qraux, ipvt, work)
      integer    nra, nca, lda, kbasis, ipvt(*)
      real       tol, a(lda,*), b(*), x(*), res(*), qr(*), qraux(*),    &
     &           work(*)
      end

      interface to subroutine lsbrr (nra, nca, a, lda, b, tol, x, res,  &
     &           kbasis)
      integer    nra, nca, lda, kbasis
      real       tol, a(lda,*), b(*), x(*), res(*)
      end

      interface to subroutine l2brr (nra, nca, a, lda, b, tol, x, res,  &
     &           kbasis, qr, brrux, ipvt, work)
      integer    nra, nca, lda, kbasis, ipvt(*)
      real       tol, a(lda,*), b(*), x(*), res(*), qr(*), brrux(*),    &
     &           work(*)
      end

      interface to subroutine lsvrr (nra, nca, a, lda, ipath, tol,      &
     &           irank, s, u, ldu, v, ldv)
      integer    nra, nca, lda, ipath, irank, ldu, ldv
      real       tol, a(lda,*), s(*), u(ldu,*), v(ldv,*)
      end

      interface to subroutine l2vrr (nra, nca, a, lda, ipath, tol,      &
     &           irank, s, u, ldu, v, ldv, wka, wk)
      integer    nra, nca, lda, ipath, irank, ldu, ldv
      real       tol, a(lda,*), s(*), u(*), v(*), wka(*), wk(*)
      end

      interface to subroutine lsgrr (nra, nca, a, lda, tol, irank,      &
     &           ginva, ldginv)
      integer    nra, nca, lda, irank, ldginv
      real       tol, a(lda,*), ginva(ldginv,*)
      end

      interface to subroutine l2grr (nra, nca, a, lda, tol, irank,      &
     &           ginva, ldginv, wka, wk)
      integer    nra, nca, lda, irank, ldginv
      real       tol, a(lda,*), ginva(ldginv,*), wka(*), wk(*)
      end

$ENDIF

!
!     Chapter 2:  Eigensystem Analysis
!

      interface to subroutine evlrg (n, a, lda, eval)
      integer    n, lda
      real       a(lda,*)
      complex    eval(*)
      end

      interface to subroutine e3lrg (n, a, lda, eval, acopy, wk, iwk)
      integer    n, lda, iwk(n,2)
      real       a(lda,*), acopy(*), wk(n,4)
      complex    eval(*)
      end

      interface to subroutine evcrg (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      real       a(lda,*)
      complex    eval(*), evec(ldevec,*)
      end

      interface to subroutine e8crg (n, a, lda, eval, evec, ldevec,     &
     &           acopy, ecopy, wk, iwk)
      integer    n, lda, ldevec, iwk(n)
      real       a(lda,*), acopy(*), ecopy(*), wk(n,6)
      complex    eval(*), evec(ldevec,*)
      end

      interface to real function epirg (n, neval, a, lda, eval, evec,   &
     &           ldevec)
      integer    n, neval, lda, ldevec
      real       a(lda,*)
      complex    eval(*), evec(ldevec,*)
      end

      interface to real function e2irg (n, neval, a, lda, eval, evec,   &
     &           ldevec, cwk)
      integer    n, neval, lda, ldevec
      real       a(lda,*)
      complex    eval(*), evec(ldevec,*), cwk(*)
      end

      interface to subroutine evlcg (n, a, lda, eval)
      integer    n, lda
      complex    a(lda,*), eval(*)
      end

      interface to subroutine e3lcg (n, a, lda, eval, acopy, rwk, cwk,  &
     &           iwk)
      integer    n, lda, iwk(n)
      real       rwk(*)
      complex    a(lda,*), eval(*), acopy(*), cwk(n,*)
      end

      interface to subroutine evccg (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      complex    a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e6ccg (n, a, lda, eval, evec, ldevec,     &
     &           acopy, rwk, cwk, iwk)
      integer    n, lda, ldevec, iwk(n)
      real       rwk(n)
      complex    a(lda,*), eval(*), evec(ldevec,*), acopy(*), cwk(n,*)
      end

      interface to real function epicg (n, neval, a, lda, eval, evec,   &
     &           ldevec)
      integer    n, neval, lda, ldevec
      complex    a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to real function e2icg (n, neval, a, lda, eval, evec,   &
     &           ldevec, wk)
      integer    n, neval, lda, ldevec
      complex    a(lda,*), eval(*), evec(ldevec,*), wk(*)
      end

      interface to subroutine evlsf (n, a, lda, eval)
      integer    n, lda
      real       a(lda,*), eval(*)
      end

      interface to subroutine e4lsf (n, a, lda, eval, wk, iwk)
      integer    n, lda, iwk(n)
      real       a(lda,*), eval(*), wk(n,2)
      end

      interface to subroutine evasf (n, neval, a, lda, small, eval)
      integer    n, neval, lda
      real       a(lda,*), eval(*)
      logical    small
      end

      interface to subroutine e4asf (n, neval, a, lda, small, eval, wk, &
     &           iwk)
      integer    n, neval, lda, iwk(n)
      real       a(lda,*), eval(*), wk(n,4)
      logical    small
      end

      interface to subroutine evesf (n, nevec, a, lda, small, eval,     &
     &           evec, ldevec)
      integer    n, nevec, lda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      logical    small
      end

      interface to subroutine e5esf (n, nevec, a, lda, small, eval,     &
     &           evec, ldevec, wk, iwk)
      integer    n, nevec, lda, ldevec, iwk(n)
      real       a(lda,*), eval(*), evec(ldevec,*), wk(n,9)
      logical    small
      end

      interface to subroutine evbsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval)
      integer    n, mxeval, lda, neval
      real       elow, ehigh, a(lda,*), eval(mxeval)
      end

      interface to subroutine e5bsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, wk, iwk)
      integer    n, mxeval, lda, neval, iwk(n)
      real       elow, ehigh, a(lda,*), eval(mxeval), wk(n,5)
      end

      interface to subroutine evfsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec)
      integer    n, mxeval, lda, neval, ldevec
      real       elow, ehigh, a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e3fsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec, wk, iwk)
      integer    n, mxeval, lda, neval, ldevec, iwk(n)
      real       elow, ehigh, a(lda,*), eval(mxeval), evec(ldevec,*),   &
     &           wk(n,9)
      end

      interface to subroutine evlsb (n, a, lda, ncoda, eval)
      integer    n, lda, ncoda
      real       a(lda,*), eval(*)
      end

      interface to subroutine e3lsb (n, a, lda, ncoda, eval, acopy, wk)
      integer    n, lda, ncoda
      real       a(lda,*), eval(*), acopy(ncoda+1,*), wk(*)
      end

      interface to subroutine evcsb (n, a, lda, ncoda, eval, evec,      &
     &           ldevec)
      integer    n, lda, ncoda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e4csb (n, a, lda, ncoda, eval, evec,      &
     &           ldevec, acopy, wk, iwk)
      integer    n, lda, ncoda, ldevec, iwk(*)
      real       a(lda,*), eval(*), evec(ldevec,*), acopy(ncoda+1,*),   &
     &           wk(*)
      end

      interface to subroutine evasb (n, neval, a, lda, ncoda, small,    &
     &           eval)
      integer    n, neval, lda, ncoda
      real       a(lda,*), eval(*)
      logical    small
      end

      interface to subroutine e3asb (n, neval, a, lda, ncoda, small,    &
     &           eval, acopy, wk)
      integer    n, neval, lda, ncoda
      real       a(lda,*), eval(*), acopy(ncoda+1,*), wk(3*n)
      logical    small
      end

      interface to subroutine evesb (n, nevec, a, lda, ncoda, small,    &
     &           eval, evec, ldevec)
      integer    n, nevec, lda, ncoda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      logical    small
      end

      interface to subroutine e4esb (n, nevec, a, lda, ncoda, small,    &
     &           eval, evec, ldevec, acopy, wk, iwk)
      integer    n, nevec, lda, ncoda, ldevec, iwk(n)
      real       a(lda,*), eval(*), evec(ldevec,*), acopy(ncoda+1,*),   &
     &           wk(n*(2*ncoda+5))
      logical    small
      end

      interface to subroutine evbsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval)
      integer    n, mxeval, lda, ncoda, neval
      real       elow, ehigh, a(lda,*), eval(*)
      end

      interface to subroutine e3bsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval, acopy, wk)
      integer    n, mxeval, lda, ncoda, neval
      real       elow, ehigh, a(lda,*), eval(*), acopy(ncoda+1,*),      &
     &           wk(n,*)
      end

      interface to subroutine evfsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval, evec, ldevec)
      integer    n, mxeval, lda, ncoda, neval, ldevec
      real       elow, ehigh, a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e3fsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval, evec, ldevec, acopy, wk1, wk2, iwk)
      integer    n, mxeval, lda, ncoda, neval, ldevec, iwk(n)
      real       elow, ehigh, a(lda,*), eval(*), evec(ldevec,*),        &
     &           acopy(ncoda+1,*), wk1(6*n), wk2(2*n*ncoda+n)
      end

      interface to real function episb (n, neval, a, lda, ncoda, eval,  &
     &           evec, ldevec)
      integer    n, neval, lda, ncoda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to real function e2isb (n, neval, a, lda, ncoda, eval,  &
     &           evec, ldevec, wk)
      integer    n, neval, lda, ncoda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*), wk(*)
      end

      interface to subroutine evlhf (n, a, lda, eval)
      integer    n, lda
      real       eval(*)
      complex    a(lda,*)
      end

      interface to subroutine e3lhf (n, a, lda, eval, acopy, rwk, cwk,  &
     &           iwk)
      integer    n, lda, iwk(n)
      real       eval(*), rwk(*)
      complex    a(lda,*), acopy(*), cwk(*)
      end

      interface to subroutine evchf (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      real       eval(*)
      complex    a(lda,*), evec(ldevec,*)
      end

      interface to subroutine e5chf (n, a, lda, eval, evec, ldevec,     &
     &           acopy, rwk, cwk, iwk)
      integer    n, lda, ldevec, iwk(n)
      real       eval(*), rwk(*)
      complex    a(lda,*), evec(ldevec,*), acopy(*), cwk(*)
      end

      interface to subroutine evahf (n, neval, a, lda, small, eval)
      integer    n, neval, lda
      real       eval(*)
      complex    a(lda,*)
      logical    small
      end

      interface to subroutine e3ahf (n, neval, a, lda, small, eval,     &
     &           acopy, rwk, cwk, iwk)
      integer    n, neval, lda, iwk(*)
      real       eval(*), rwk(n,*)
      complex    a(lda,*), acopy(n,*), cwk(n,*)
      logical    small
      end

      interface to subroutine evehf (n, nevec, a, lda, small, eval,     &
     &           evec, ldevec)
      integer    n, nevec, lda, ldevec
      real       eval(*)
      complex    a(lda,*), evec(ldevec,*)
      logical    small
      end

      interface to subroutine e3ehf (n, nevec, a, lda, small, eval,     &
     &           evec, ldevec, acopy, rw1, rw2, cwk, iwk)
      integer    n, nevec, lda, ldevec, iwk(*)
      real       eval(*), rw1(n,*), rw2(n,*)
      complex    a(lda,*), evec(ldevec,*), acopy(n,*), cwk(n,*)
      logical    small
      end

      interface to subroutine evbhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval)
      integer    n, mxeval, lda, neval
      real       elow, ehigh, eval(*)
      complex    a(lda,*)
      end

      interface to subroutine e3bhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, acopy, rwk, cwk, iwk)
      integer    n, mxeval, lda, neval, iwk(*)
      real       elow, ehigh, eval(*), rwk(n,*)
      complex    a(lda,*), acopy(n,*), cwk(n,*)
      end

      interface to subroutine evfhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec)
      integer    n, mxeval, lda, neval, ldevec
      real       elow, ehigh, eval(*)
      complex    a(lda,*), evec(ldevec,*)
      end

      interface to subroutine e3fhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec, acopy, ecopy, rwk, cwk, iwk)
      integer    n, mxeval, lda, neval, ldevec, iwk(*)
      real       elow, ehigh, eval(*), ecopy(n,*), rwk(n,*)
      complex    a(lda,*), evec(ldevec,*), acopy(n,*), cwk(n,*)
      end

      interface to real function epihf (n, neval, a, lda, eval, evec,   &
     &           ldevec)
      integer    n, neval, lda, ldevec
      real       eval(*)
      complex    a(lda,*), evec(ldevec,*)
      end

      interface to real function e2ihf (n, neval, a, lda, eval, evec,   &
     &           ldevec, wk)
      integer    n, neval, lda, ldevec
      real       eval(*)
      complex    a(lda,*), evec(ldevec,*), wk(*)
      end

      interface to subroutine evlrh (n, a, lda, eval)
      integer    n, lda
      real       a(lda,*)
      complex    eval(*)
      end

      interface to subroutine e3lrh (n, a, lda, eval, acopy, wk, iwk)
      integer    n, lda, iwk(n,1)
      real       a(lda,*), acopy(n,*), wk(n,3)
      complex    eval(*)
      end

      interface to subroutine evcrh (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      real       a(lda,*)
      complex    eval(*), evec(ldevec,*)
      end

      interface to subroutine e6crh (n, a, lda, eval, evec, ldevec,     &
     &           acopy, ecopy, rwk, iwk)
      integer    n, lda, ldevec, iwk(n)
      real       a(lda,*), acopy(n,*), ecopy(n,n), rwk(n,3)
      complex    eval(*), evec(ldevec,*)
      end

      interface to subroutine evlch (n, a, lda, eval)
      integer    n, lda
      complex    a(lda,*), eval(*)
      end

      interface to subroutine e3lch (n, a, lda, eval, acopy, rwk, iwk)
      integer    n, lda, iwk(n)
      complex    a(lda,*), eval(*), acopy(n,*)
      real       rwk(n)
      end

      interface to subroutine evcch (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      complex    a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e4cch (n, a, lda, eval, evec, ldevec,     &
     &           acopy, cwork, rwk, iwk)
      integer    n, lda, ldevec, iwk(n)
      real       rwk(n)
      complex    a(lda,*), eval(*), evec(ldevec,*), acopy(n,*),         &
     &           cwork(n,*)
      end

      interface to subroutine gvlrg (n, a, lda, b, ldb, alpha, beta)
      integer    n, lda, ldb
      real       a(lda,*), b(ldb,*), beta(*)
      complex    alpha(*)
      end

      interface to subroutine g3lrg (n, a, lda, b, ldb, alpha, beta,    &
     &           acopy, bcopy, rwk, cwk, iwk)
      integer    n, lda, ldb, iwk(n)
      real       a(lda,*), b(ldb,*), beta(*), acopy(*), bcopy(*),       &
     &           rwk(*)
      complex    alpha(*), cwk(*)
      end

      interface to subroutine gvcrg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec)
      integer    n, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), beta(*)
      complex    alpha(*), evec(ldevec,*)
      end

      interface to subroutine g8crg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec, acopy, bcopy, ecopy, rwk, cwk, iwk)
      integer    n, lda, ldb, ldevec, iwk(n)
      real       a(lda,*), b(ldb,*), beta(*), acopy(*), bcopy(*),       &
     &           ecopy(*), rwk(*)
      complex    alpha(*), evec(ldevec,*), cwk(*)
      end

      interface to real function gpirg (n, neval, a, lda, b, ldb, alpha,&
     &           beta, evec, ldevec)
      integer    n, neval, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), beta(*)
      complex    alpha(*), evec(ldevec,*)
      end

      interface to real function g2irg (n, neval, a, lda, b, ldb, alpha,&
     &           beta, evec, ldevec, wk)
      integer    n, neval, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), beta(*)
      complex    alpha(*), evec(ldevec,*), wk(n,*)
      end

      interface to subroutine gvlcg (n, a, lda, b, ldb, alpha, beta)
      integer    n, lda, ldb
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*)
      end

      interface to subroutine g3lcg (n, a, lda, b, ldb, alpha, beta,    &
     &           acopy, bcopy, cwk, wk, iwk)
      integer    n, lda, ldb, iwk(n)
      real       wk(n)
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*), acopy(n,*),     &
     &           bcopy(n,*), cwk(n)
      end

      interface to subroutine gvccg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec)
      integer    n, lda, ldb, ldevec
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*), evec(ldevec,*)
      end

      interface to subroutine g6ccg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec, acopy, bcopy, cwk, wk, iwk)
      integer    n, lda, ldb, ldevec, iwk(n)
      real       wk(n)
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*),                 &
     &           evec(ldevec,*), acopy(n,*), bcopy(n,*), cwk(n)
      end

      interface to real function gpicg (n, neval, a, lda, b, ldb, alpha,&
     &           beta, evec, ldevec)
      integer    n, neval, lda, ldb, ldevec
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*), evec(ldevec,*)
      end

      interface to real function g2icg (n, neval, a, lda, b, ldb, alpha,&
     &           beta, evec, ldevec, wk)
      integer    n, neval, lda, ldb, ldevec
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*),                 &
     &           evec(ldevec,*), wk(n,*)
      end

      interface to subroutine gvcsp (n, a, lda, b, ldb, eval, evec,     &
     &           ldevec)
      integer    n, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine g3csp (n, a, lda, b, ldb, eval, evec,     &
     &           ldevec, iwk, wk1, wk2)
      integer    n, lda, ldb, ldevec, iwk(*)
      real       a(lda,*), b(ldb,*), eval(*), evec(ldevec,*),           &
     &           wk1(n,*), wk2(n+1,*)
      end

      interface to real function gpisp (n, neval, a, lda, b, ldb, eval, &
     &           evec, ldevec)
      integer    n, neval, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), eval(*), evec(ldevec,*)
      end

      interface to real function g2isp (n, neval, a, lda, b, ldb, eval, &
     &           evec, ldevec, work)
      integer    n, neval, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), eval(*), evec(ldevec,*), work(n,*)
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine evcsf (n, a, lda, eval, evec, ldevec)
      integer    n, lda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to subroutine e5csf (n, a, lda, eval, evec, ldevec, wk, &
     &           iwk)
      integer    n, lda, ldevec, iwk(n)
      real       a(lda,*), eval(*), evec(ldevec,*), wk(n,3)
      end

      interface to real function episf (n, neval, a, lda, eval, evec,   &
     &           ldevec)
      integer    n, neval, lda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*)
      end

      interface to real function e2isf (n, neval, a, lda, eval, evec,   &
     &           ldevec, work)
      integer    n, neval, lda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*), work(*)
      end

      interface to subroutine gvlsp (n, a, lda, b, ldb, eval)
      integer    n, lda, ldb
      real       a(lda,*), b(ldb,*), eval(*)
      end

      interface to subroutine g3lsp (n, a, lda, b, ldb, eval, iwk, wk,  &
     &           s)
      integer    n, lda, ldb, iwk(*)
      real       a(lda,*), b(ldb,*), eval(*), wk(n,*), s(n+1,*)
      end

$ENDIF

!
!     Chapter 3:  Interpolation and Approximation
!

      interface to subroutine csiez (ndata, xdata, fdata, n, xvec,      &
     &           value)
      integer    ndata, n
      real       xdata(*), fdata(*), xvec(*), value(*)
      end

      interface to subroutine c2iez (ndata, xdata, fdata, n, xvec,      &
     &           value, iwk, wk1, wk2)
      integer    ndata, n, iwk(*)
      real       xdata(*), fdata(*), xvec(*), value(*), wk1(*), wk2(*)
      end

      interface to subroutine csint (ndata, xdata, fdata, break, cscoef)
      integer    ndata
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2int (ndata, xdata, fdata, break, cscoef,&
     &           ipvt)
      integer    ndata, ipvt(*)
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine csdec (ndata, xdata, fdata, ileft, dleft, &
     &           iright, dright, break, cscoef)
      integer    ndata, ileft, iright
      real       dleft, dright, xdata(*), fdata(*), break(*),           &
     &           cscoef(4,*)
      end

      interface to subroutine c2dec (ndata, xdata, fdata, ileft, dleft, &
     &           iright, dright, break, cscoef, ipvt)
      integer    ndata, ileft, iright, ipvt(*)
      real       dleft, dright, xdata(*), fdata(*), break(*),           &
     &           cscoef(4,*)
      end

      interface to subroutine csher (ndata, xdata, fdata, dfdata, break,&
     &           cscoef)
      integer    ndata
      real       xdata(*), fdata(*), dfdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2her (ndata, xdata, fdata, dfdata, break,&
     &           cscoef, ipvt)
      integer    ndata, ipvt(*)
      real       xdata(*), fdata(*), dfdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine csakm (ndata, xdata, fdata, break, cscoef)
      integer    ndata
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2akm (ndata, xdata, fdata, break, cscoef,&
     &           ipvt)
      integer    ndata, ipvt(*)
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine cscon (ndata, xdata, fdata, ibreak, break,&
     &           cscoef)
      integer    ndata, ibreak
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2con (ndata, xdata, fdata, ibreak, break,&
     &           cscoef, itmax, xsrt, fsrt, a, y, divd, id, wk)
      integer    ndata, ibreak, itmax, id(*)
      real       xdata(*), fdata(*), break(*), cscoef(4,*), xsrt(*),    &
     &           fsrt(*), a(*), y(*), divd(*), wk(*)
      end

      interface to subroutine csper (ndata, xdata, fdata, break, cscoef)
      integer    ndata
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2per (ndata, xdata, fdata, break, cscoef,&
     &           work, ipvt)
      integer    ndata, ipvt(*)
      real       xdata(*), fdata(*), break(*), cscoef(4,*), work(6,*)
      end

      interface to real function csval (x, nintv, break, cscoef)
      integer    nintv
      real       x, break(*), cscoef(4,*)
      end

      interface to real function csder (ideriv, x, nintv, break, cscoef)
      integer    ideriv, nintv
      real       x, break(*), cscoef(4,*)
      end

      interface to subroutine cs1gd (ideriv, n, xvec, nintv, break,     &
     &           cscoef, value)
      integer    ideriv, n, nintv
      real       xvec(*), break(*), cscoef(4,*), value(*)
      end

      interface to subroutine c21gd (ideriv, n, xvec, nintv, break,     &
     &           cscoef, value, left, h, p)
      integer    ideriv, n, nintv, left(*)
      real       xvec(*), break(*), cscoef(4,*), value(*), h(*), p(*)
      end

      interface to real function csitg (a, b, nintv, break, cscoef)
      integer    nintv
      real       a, b, break(*), cscoef(4,*)
      end

      interface to subroutine splez (ndata, xdata, fdata, itype, ider,  &
     &           n, xvec, value)
      integer    ndata, itype, ider, n
      real       xdata(*), fdata(*), xvec(*), value(*)
      end

      interface to subroutine s2lez (ndata, xdata, fdata, itype, ider,  &
     &           n, xvec, value, wk, iwk)
      integer    ndata, itype, ider, n, iwk(*)
      real       xdata(*), fdata(*), xvec(*), value(*), wk(*)
      end

      interface to subroutine bsint (ndata, xdata, fdata, korder, xknot,&
     &           bscoef)
      integer    ndata, korder
      real       xdata(*), fdata(*), xknot(*), bscoef(*)
      end

      interface to subroutine b2int (ndata, xdata, fdata, korder, xknot,&
     &           bscoef, work1, work2, work3, iwork)
      integer    ndata, korder, iwork(*)
      real       xdata(*), fdata(*), xknot(*), bscoef(*), work1(*),     &
     &           work2(*), work3(*)
      end

      interface to subroutine bsnak (ndata, xdata, korder, xknot)
      integer    ndata, korder
      real       xdata(*), xknot(*)
      end

      interface to subroutine b2nak (ndata, xdata, korder, xknot, xsrt, &
     &           iwk)
      integer    ndata, korder, iwk(*)
      real       xdata(*), xknot(*), xsrt(*)
      end

      interface to subroutine bsopk (ndata, xdata, korder, xknot)
      integer    ndata, korder
      real       xdata(*), xknot(*)
      end

      interface to subroutine b2opk (ndata, xdata, korder, xknot, maxit,&
     &           wk, iwk)
      integer    ndata, korder, maxit, iwk(*)
      real       xdata(*), xknot(*), wk(*)
      end

      interface to subroutine bs2in (nxdata, xdata, nydata, ydata,      &
     &           fdata, ldf, kxord, kyord, xknot, yknot, bscoef)
      integer    nxdata, nydata, ldf, kxord, kyord
      real       xdata(*), ydata(*), fdata(*), xknot(*), yknot(*),      &
     &           bscoef(*)
      end

      interface to subroutine b22in (nxdata, xdata, nydata, ydata,      &
     &           fdata, ldf, kxord, kyord, xknot, yknot, bscoef, wk,    &
     &           iwk)
      integer    nxdata, nydata, ldf, kxord, kyord, iwk(*)
      real       xdata(*), ydata(*), fdata(ldf,*), xknot(*), yknot(*),  &
     &           bscoef(*), wk(*)
      end

      interface to subroutine bs3in (nxdata, xdata, nydata, ydata,      &
     &           nzdata, zdata, fdata, ldf, mdf, kxord, kyord, kzord,   &
     &           xknot, yknot, zknot, bscoef)
      integer    nxdata, nydata, nzdata, ldf, mdf, kxord, kyord, kzord
      real       xdata(*), ydata(*), zdata(*), fdata(*), xknot(*),      &
     &           yknot(*), zknot(*), bscoef(*)
      end

      interface to subroutine b23in (nxdata, xdata, nydata, ydata,      &
     &           nzdata, zdata, fdata, ldf, mdf, kxord, kyord, kzord,   &
     &           xknot, yknot, zknot, bscoef, wk, iwk)
      integer    nxdata, nydata, nzdata, ldf, mdf, kxord, kyord,        &
     &           kzord, iwk(*)
      real       xdata(*), ydata(*), zdata(*), fdata(ldf,mdf,*),        &
     &           xknot(*), yknot(*), zknot(*), bscoef(*), wk(*)
      end

      interface to real function bsval (x, korder, xknot, ncoef, bscoef)
      integer    korder, ncoef
      real       x, xknot(*), bscoef(*)
      end

      interface to real function b2val (x, korder, xknot, ncoef, bscoef,&
     &           aj, dl, dr)
      integer    korder, ncoef
      real       x, xknot(*), bscoef(*), aj(*), dl(*), dr(*)
      end

      interface to real function bsder (ideriv, x, korder, xknot, ncoef,&
     &           bscoef)
      integer    ideriv, korder, ncoef
      real       x, xknot(*), bscoef(*)
      end

      interface to real function b2der (ideriv, x, korder, xknot, ncoef,&
     &           bscoef, aj, dl, dr)
      integer    ideriv, korder, ncoef
      real       x, xknot(*), bscoef(*), aj(*), dl(*), dr(*)
      end

      interface to subroutine bs1gd (ideriv, n, xvec, korder, xknot,    &
     &           ncoef, bscoef, value)
      integer    ideriv, n, korder, ncoef
      real       xvec(*), xknot(*), bscoef(*), value(*)
      end

      interface to subroutine b21gd (ideriv, n, xvec, korder, xknot,    &
     &           ncoef, bscoef, value, ppcoef, break, left, h, p, wk)
      integer    ideriv, n, korder, ncoef, left(*)
      real       xvec(*), xknot(*), bscoef(*), value(*),                &
     &           ppcoef(korder,*), break(*), h(*), p(*), wk(*)
      end

      interface to real function bsitg (a, b, korder, xknot, ncoef,     &
     &           bscoef)
      integer    korder, ncoef
      real       a, b, xknot(*), bscoef(*)
      end

      interface to real function b2itg (a, b, korder, xknot, ncoef,     &
     &           bscoef, tcoef, aj, dl, dr)
      integer    korder, ncoef
      real       a, b, xknot(*), bscoef(*), tcoef(0:*), aj(*), dl(*),   &
     &           dr(*)
      end

      interface to real function bs2vl (x, y, kxord, kyord, xknot,      &
     &           yknot, nxcoef, nycoef, bscoef)
      integer    kxord, kyord, nxcoef, nycoef
      real       x, y, xknot(*), yknot(*), bscoef(*)
      end

      interface to real function b22vl (x, y, kxord, kyord, xknot,      &
     &           yknot, nxcoef, nycoef, bscoef, wk)
      integer    kxord, kyord, nxcoef, nycoef
      real       x, y, xknot(*), yknot(*), bscoef(*), wk(*)
      end

      interface to real function bs2dr (ixder, iyder, x, y, kxord,      &
     &           kyord, xknot, yknot, nxcoef, nycoef, bscoef)
      integer    ixder, iyder, kxord, kyord, nxcoef, nycoef
      real       x, y, xknot(*), yknot(*), bscoef(*)
      end

      interface to real function b22dr (ixder, iyder, x, y, kxord,      &
     &           kyord, xknot, yknot, nxcoef, nycoef, bscoef, wk)
      integer    ixder, iyder, kxord, kyord, nxcoef, nycoef
      real       x, y, xknot(*), yknot(*), bscoef(nxcoef,*), wk(*)
      end

      interface to subroutine bs2gd (ixder, iyder, nx, xvec, ny, yvec,  &
     &           kxord, kyord, xknot, yknot, nxcoef, nycoef, bscoef,    &
     &           value, ldvalu)
      integer    ixder, iyder, nx, ny, kxord, kyord, nxcoef, nycoef,    &
     &           ldvalu
      real       xvec(*), yvec(*), xknot(*), yknot(*), bscoef(*),       &
     &           value(ldvalu,*)
      end

      interface to subroutine b22gd (ixder, iyder, nx, xvec, ny, yvec,  &
     &           kxord, kyord, xknot, yknot, nxcoef, nycoef, bscoef,    &
     &           value, ldvalu, leftx, lefty, a, b, dbiatx, dbiaty, bx, &
     &           by)
      integer    ixder, iyder, nx, ny, kxord, kyord, nxcoef, nycoef,    &
     &           ldvalu, leftx(*), lefty(*)
      real       xvec(*), yvec(*), xknot(*), yknot(*),                  &
     &           bscoef(nxcoef,*), value(ldvalu,*), a(kxord,*),         &
     &           b(kyord,*), dbiatx(kxord,*), dbiaty(kyord,*),          &
     &           bx(kxord,*), by(kyord,*)
      end

      interface to real function bs2ig (a, b, c, d, kxord, kyord, xknot,&
     &           yknot, nxcoef, nycoef, bscoef)
      integer    kxord, kyord, nxcoef, nycoef
      real       a, b, c, d, xknot(*), yknot(*), bscoef(*)
      end

      interface to real function b22ig (a, b, c, d, kxord, kyord, xknot,&
     &           yknot, nxcoef, nycoef, bscoef, wk)
      integer    kxord, kyord, nxcoef, nycoef
      real       a, b, c, d, xknot(*), yknot(*), bscoef(nxcoef,*),      &
     &           wk(*)
      end

      interface to real function bs3vl (x, y, z, kxord, kyord, kzord,   &
     &           xknot, yknot, zknot, nxcoef, nycoef, nzcoef, bscoef)
      integer    kxord, kyord, kzord, nxcoef, nycoef, nzcoef
      real       x, y, z, xknot(*), yknot(*), zknot(*), bscoef(*)
      end

      interface to real function b23vl (x, y, z, kxord, kyord, kzord,   &
     &           xknot, yknot, zknot, nxcoef, nycoef, nzcoef, bscoef,   &
     &           wk)
      integer    kxord, kyord, kzord, nxcoef, nycoef, nzcoef
      real       x, y, z, xknot(*), yknot(*), zknot(*),                 &
     &           bscoef(nxcoef,nycoef,*), wk(*)
      end

      interface to real function bs3dr (ixder, iyder, izder, x, y, z,   &
     &           kxord, kyord, kzord, xknot, yknot, zknot, nxcoef,      &
     &           nycoef, nzcoef, bscoef)
      integer    ixder, iyder, izder, kxord, kyord, kzord, nxcoef,      &
     &           nycoef, nzcoef
      real       x, y, z, xknot(*), yknot(*), zknot(*), bscoef(*)
      end

      interface to real function b23dr (ixder, iyder, izder, x, y, z,   &
     &           kxord, kyord, kzord, xknot, yknot, zknot, nxcoef,      &
     &           nycoef, nzcoef, bscoef, wk)
      integer    ixder, iyder, izder, kxord, kyord, kzord, nxcoef,      &
     &           nycoef, nzcoef
      real       x, y, z, xknot(*), yknot(*), zknot(*),                 &
     &           bscoef(nxcoef,nycoef,*), wk(*)
      end

      interface to subroutine bs3gd (ixder, iyder, izder, nx, xvec, ny, &
     &           yvec, nz, zvec, kxord, kyord, kzord, xknot, yknot,     &
     &           zknot, nxcoef, nycoef, nzcoef, bscoef, value, ldvalu,  &
     &           mdvalu)
      integer    ixder, iyder, izder, nx, ny, nz, kxord, kyord, kzord,  &
     &           nxcoef, nycoef, nzcoef, ldvalu, mdvalu
      real       xvec(*), yvec(*), zvec(*), xknot(*), yknot(*),         &
     &           zknot(*), bscoef(*), value(ldvalu,mdvalu,*)
      end

      interface to subroutine b23gd (ixder, iyder, izder, nx, xvec, ny, &
     &           yvec, nz, zvec, kxord, kyord, kzord, xknot, yknot,     &
     &           zknot, nxcoef, nycoef, nzcoef, bscoef, value, ldvalu,  &
     &           mdvalu, leftx, lefty, leftz, a, b, c, dbiatx, dbiaty,  &
     &           dbiatz, bx, by, bz)
      integer    ixder, iyder, izder, nx, ny, nz, kxord, kyord, kzord,  &
     &           nxcoef, nycoef, nzcoef, ldvalu, mdvalu, leftx(*),      &
     &           lefty(*), leftz(*)
      real       xvec(*), yvec(*), zvec(*), xknot(*), yknot(*),         &
     &           zknot(*), bscoef(nxcoef,nycoef,*),                     &
     &           value(ldvalu,mdvalu,*), a(kxord,*), b(kyord,*),        &
     &           c(kzord,*), dbiatx(kxord,*), dbiaty(kyord,*),          &
     &           dbiatz(kzord,*), bx(kxord,*), by(kyord,*), bz(kzord,*)
      end

      interface to real function bs3ig (a, b, c, d, e, f, kxord, kyord, &
     &           kzord, xknot, yknot, zknot, nxcoef, nycoef, nzcoef,    &
     &           bscoef)
      integer    kxord, kyord, kzord, nxcoef, nycoef, nzcoef
      real       a, b, c, d, e, f, xknot(*), yknot(*), zknot(*),        &
     &           bscoef(*)
      end

      interface to real function b23ig (a, b, c, d, e, f, kxord, kyord, &
     &           kzord, xknot, yknot, zknot, nxcoef, nycoef, nzcoef,    &
     &           bscoef, wk)
      integer    kxord, kyord, kzord, nxcoef, nycoef, nzcoef
      real       a, b, c, d, e, f, xknot(*), yknot(*), zknot(*),        &
     &           bscoef(*), wk(*)
      end

      interface to subroutine bscpp (korder, xknot, ncoef, bscoef,      &
     &           nppcf, break, ppcoef)
      integer    korder, ncoef, nppcf
      real       xknot(*), bscoef(*), break(*), ppcoef(*)
      end

      interface to subroutine b2cpp (korder, xknot, ncoef, bscoef,      &
     &           nppcf, break, ppcoef, wk)
      integer    korder, ncoef, nppcf
      real       xknot(*), bscoef(*), break(*), ppcoef(*), wk(*)
      end

      interface to real function ppval (x, korder, nintv, break, ppcoef)
      integer    korder, nintv
      real       x, break(*), ppcoef(*)
      end

      interface to real function ppder (ideriv, x, korder, nintv, break,&
     &           ppcoef)
      integer    ideriv, korder, nintv
      real       x, break(*), ppcoef(korder,*)
      end

      interface to subroutine pp1gd (ideriv, n, xvec, korder, nintv,    &
     &           break, ppcoef, value)
      integer    ideriv, n, korder, nintv
      real       xvec(*), break(*), ppcoef(*), value(*)
      end

      interface to subroutine p21gd (ideriv, n, xvec, korder, nintv,    &
     &           break, ppcoef, value, left, h, p)
      integer    ideriv, n, korder, nintv, left(*)
      real       xvec(*), break(*), ppcoef(korder,*), value(*), h(*),   &
     &           p(*)
      end

      interface to real function ppitg (a, b, korder, nintv, break,     &
     &           ppcoef)
      integer    korder, nintv
      real       a, b, break(*), ppcoef(korder,*)
      end

      interface to real function qdval (x, ndata, xdata, fdata, check)
      integer    ndata
      real       x, xdata(*), fdata(*)
      logical    check
      end

      interface to real function qdder (ideriv, x, ndata, xdata, fdata, &
     &           check)
      integer    ideriv, ndata
      real       x, xdata(*), fdata(*)
      logical    check
      end

      interface to real function qd2vl (x, y, nxdata, xdata, nydata,    &
     &           ydata, fdata, ldf, check)
      integer    nxdata, nydata, ldf
      real       x, y, xdata(*), ydata(*), fdata(*)
      logical    check
      end

      interface to real function qd2dr (ixder, iyder, x, y, nxdata,     &
     &           xdata, nydata, ydata, fdata, ldf, check)
      integer    ixder, iyder, nxdata, nydata, ldf
      real       x, y, xdata(*), ydata(*), fdata(ldf,*)
      logical    check
      end

      interface to real function qd3vl (x, y, z, nxdata, xdata, nydata, &
     &           ydata, nzdata, zdata, fdata, ldf, mdf, check)
      integer    nxdata, nydata, nzdata, ldf, mdf
      real       x, y, z, xdata(*), ydata(*), zdata(*), fdata(*)
      logical    check
      end

      interface to real function qd3dr (ixder, iyder, izder, x, y, z,   &
     &           nxdata, xdata, nydata, ydata, nzdata, zdata, fdata,    &
     &           ldf, mdf, check)
      integer    ixder, iyder, izder, nxdata, nydata, nzdata, ldf, mdf
      real       x, y, z, xdata(*), ydata(*), zdata(*),                 &
     &           fdata(ldf,mdf,*)
      logical    check
      end

      interface to subroutine surf (ndata, xydata, fdata, nxout, nyout, &
     &           xout, yout, sur, ldsur)
      integer    ndata, nxout, nyout, ldsur
      real       xydata(2,*), fdata(*), xout(*), yout(*), sur(*)
      end

      interface to subroutine s2rf (ndata, xydata, fdata, nxout, nyout, &
     &           xout, yout, sur, ldsur, iwk, wk)
      integer    ndata, nxout, nyout, ldsur, iwk(*)
      real       xydata(2,*), fdata(*), xout(*), yout(*),               &
     &           sur(ldsur,*), wk(*)
      end

      interface to subroutine fnlsq (f, intcep, nbasis, ndata, xdata,   &
     &           fdata, iwt, weight, a, sse)
      integer    intcep, nbasis, ndata, iwt
      real       f, sse, xdata(*), fdata(*), weight(*), a(*)
      external   f
      end

      interface to subroutine f2lsq (f, intcep, nbasis, ndata, xdata,   &
     &           fdata, iwt, weight, a, sse, wk)
      integer    intcep, nbasis, ndata, iwt
      real       f, sse, xdata(*), fdata(*), weight(*), a(*), wk(*)
      external   f
      end

      interface to subroutine bslsq (ndata, xdata, fdata, weight,       &
     &           korder, xknot, ncoef, bscoef)
      integer    ndata, korder, ncoef
      real       xdata(*), fdata(*), weight(*), xknot(*), bscoef(*)
      end

      interface to subroutine b2lsq (ndata, xdata, fdata, weight,       &
     &           korder, xknot, ncoef, bscoef, wk, xsort, fsort, wsort, &
     &           ipvt)
      integer    ndata, korder, ncoef, ipvt(*)
      real       xdata(*), fdata(*), weight(*), xknot(*), bscoef(*),    &
     &           wk(*), xsort(*), fsort(*), wsort(*)
      end

      interface to subroutine bsvls (ndata, xdata, fdata, weight,       &
     &           korder, ncoef, xguess, xknot, bscoef, ssq)
      integer    ndata, korder, ncoef
      real       ssq, xdata(*), fdata(*), weight(*), xguess(*),         &
     &           xknot(*), bscoef(*)
      end

      interface to subroutine b2vls (ndata, xdata, fdata, weight,       &
     &           korder, ncoef, xguess, xknot, bscoef, ssq, iwk, wk)
      integer    ndata, korder, ncoef, iwk(*)
      real       ssq, xdata(*), fdata(*), weight(*), xguess(*),         &
     &           xknot(*), bscoef(*), wk(*)
      end

      interface to subroutine conft (ndata, xdata, fdata, weight, nxval,&
     &           xval, nhard, ider, itype, bl, bu, korder, xknot, ncoef,&
     &           bscoef)
      integer    ndata, nxval, nhard, korder, ncoef, ider(*), itype(*)
      real       xdata(*), fdata(*), weight(*), xval(*), bl(*), bu(*),  &
     &           xknot(*), bscoef(*)
      end

      interface to subroutine c2nft (ndata, xdata, fdata, weight, nxval,&
     &           xval, nhard, ider, itype, bl, bu, korder, xknot, ncoef,&
     &           bscoef, h, g, a, rhs, wk, iperm, iwk)
      integer    ndata, nhard, nxval, korder, ncoef, ider(*),           &
     &           itype(*), iperm(*), iwk(*)
      real       xdata(*), fdata(*), weight(*), xval(*), bl(*), bu(*),  &
     &           xknot(*), bscoef(*), h(*), g(*), a(*), rhs(*), wk(*)
      end

      interface to subroutine bsls2 (nxdata, xdata, nydata, ydata,      &
     &           fdata, ldf, kxord, kyord, xknot, yknot, nxcoef, nycoef,&
     &           xweigh, yweigh, bscoef)
      integer    nxdata, nydata, ldf, kxord, kyord, nxcoef, nycoef
      real       xdata(*), ydata(*), fdata(*), xknot(*), yknot(*),      &
     &           xweigh(*), yweigh(*), bscoef(*)
      end

      interface to subroutine b2ls2 (nxdata, xdata, nydata, ydata,      &
     &           fdata, ldf, kxord, kyord, xknot, yknot, nxcoef, nycoef,&
     &           xweigh, yweigh, bscoef, wk)
      integer    nxdata, nydata, ldf, kxord, kyord, nxcoef, nycoef
      real       xdata(*), ydata(*), fdata(*), xknot(*), yknot(*),      &
     &           xweigh(*), yweigh(*), bscoef(*), wk(*)
      end

      interface to subroutine bsls3 (nxdata, xdata, nydata, ydata,      &
     &           nzdata, zdata, fdata, ldfdat, mdfdat, kxord, kyord,    &
     &           kzord, xknot, yknot, zknot, nxcoef, nycoef, nzcoef,    &
     &           xweigh, yweigh, zweigh, bscoef)
      integer    nxdata, nydata, nzdata, ldfdat, mdfdat, kxord, kyord,  &
     &           kzord, nxcoef, nycoef, nzcoef
      real       xdata(*), ydata(*), zdata(*), fdata(*), xknot(*),      &
     &           yknot(*), zknot(*), xweigh(*), yweigh(*), zweigh(*),   &
     &           bscoef(nxcoef,nycoef,*)
      end

      interface to subroutine b2ls3 (nxdata, xdata, nydata, ydata,      &
     &           nzdata, zdata, fdata, ldfdat, mdfdat, kxord, kyord,    &
     &           kzord, xknot, yknot, zknot, nxcoef, nycoef, nzcoef,    &
     &           xweigh, yweigh, zweigh, bscoef, wk)
      integer    nxdata, nydata, nzdata, ldfdat, mdfdat, kxord, kyord,  &
     &           kzord, nxcoef, nycoef, nzcoef
      real       zknot(*), xdata(*), ydata(*), zdata(*), fdata(*),      &
     &           xknot(*), yknot(*), xweigh(*), yweigh(*), zweigh(*),   &
     &           bscoef(*), wk(*)
      end

      interface to subroutine cssed (ndata, xdata, fdata, dis, sc,      &
     &           maxit, sdata)
      integer    ndata, maxit
      real       dis, sc, xdata(*), fdata(*), sdata(*)
      end

      interface to subroutine c2sed (ndata, xdata, fdata, dis, sc,      &
     &           maxit, sdata, wk, iwk)
      integer    ndata, maxit, iwk(*)
      real       dis, sc, xdata(*), fdata(*), sdata(*), wk(*)
      end

      interface to subroutine cssmh (ndata, xdata, fdata, weight, smpar,&
     &           break, cscoef)
      integer    ndata
      real       smpar, xdata(*), fdata(*), weight(*), break(*),        &
     &           cscoef(4,*)
      end

      interface to subroutine c2smh (ndata, xdata, fdata, weight, smpar,&
     &           break, cscoef, wk, iwk)
      integer    ndata, iwk(*)
      real       smpar, xdata(*), fdata(*), weight(*), break(*),        &
     &           cscoef(4,*), wk(*)
      end

      interface to subroutine csscv (ndata, xdata, fdata, iequal, break,&
     &           cscoef)
      integer    ndata, iequal
      real       xdata(*), fdata(*), break(*), cscoef(4,*)
      end

      interface to subroutine c2scv (ndata, xdata, fdata, iequal, break,&
     &           cscoef, wk, ywk, iwk)
      integer    ndata, iequal, iwk(*)
      real       xdata(*), fdata(*), break(*), cscoef(4,*),             &
     &           wk(0:ndata+1,7), ywk(*)
      end

      interface to subroutine ratch (f, phi, weight, a, b, n, m, p, q,  &
     &           error)
      integer    n, m
      real       f, phi, weight, a, b, error, p(*), q(*)
      external   f, phi, weight
      end

      interface to subroutine r2tch (f, phi, weight, a, b, n, m, p, q,  &
     &           error, itmax, iwk, wk)
      integer    n, m, itmax, iwk(*)
      real       f, phi, weight, a, b, error, p(*), q(*), wk(*)
      external   f, phi, weight
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine rline (nobs, xdata, ydata, b0, b1, stat)
      integer    nobs
      real       b0, b1, xdata(*), ydata(*), stat(12)
      end

      interface to subroutine rcurv (nobs, xdata, ydata, ndeg, b,       &
     &           sspoly, stat)
      integer    nobs, ndeg
      real       xdata(*), ydata(*), b(*), sspoly(*), stat(10)
      end

      interface to subroutine r2urv (nobs, x, y, ndeg, b, sspoly, stat, &
     &           wk, iwk)
      integer    nobs, ndeg, iwk(*)
      real       x(*), y(*), b(*), sspoly(*), stat(10), wk(*)
      end

$ENDIF

!
!     Chapter 4:  Integration and Differentiation
!

      interface to subroutine qdag (f, a, b, errabs, errrel, irule,     &
     &           result, errest)
      integer    irule
      real       f, a, b, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2ag (f, a, b, errabs, errrel, irule,     &
     &           result, errest, maxsub, neval, nsubin, alist, blist,   &
     &           rlist, elist, iord)
      integer    irule, maxsub, neval, nsubin, iord(*)
      real       f, a, b, errabs, errrel, result, errest, alist(*),     &
     &           blist(*), rlist(*), elist(*)
      external   f
      end

      interface to subroutine qdagp (f, a, b, npts, points, errabs,     &
     &           errrel, result, errest)
      integer    npts
      real       f, a, b, errabs, errrel, result, errest, points(*)
      external   f
      end

      interface to subroutine q2agp (f, a, b, npts, points, errabs,     &
     &           errrel, result, errest, maxsub, neval, nsubin, alist,  &
     &           blist, rlist, elist, iord, level, wk, iwk)
      integer    npts, maxsub, neval, nsubin, iord(*), level(*), iwk(*)
      real       f, a, b, errabs, errrel, result, errest, points(*),    &
     &           alist(*), blist(*), rlist(*), elist(*), wk(*)
      external   f
      end

      interface to subroutine qdagi (f, bound, interv, errabs, errrel,  &
     &           result, errest)
      integer    interv
      real       f, bound, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2agi (f, bound, interv, errabs, errrel,  &
     &           result, errest, maxsub, neval, nsubin, alist, blist,   &
     &           rlist, elist, iord)
      integer    interv, maxsub, neval, nsubin, iord(*)
      real       f, bound, errabs, errrel, result, errest, alist(*),    &
     &           blist(*), rlist(*), elist(*)
      end

      interface to subroutine qdawo (f, a, b, iweigh, omega, errabs,    &
     &           errrel, result, errest)
      integer    iweigh
      real       f, a, b, omega, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2awo (f, a, b, iweigh, omega, errabs,    &
     &           errrel, result, errest, maxsub, maxcby, neval, nsubin, &
     &           alist, blist, rlist, elist, iord, nnlog, wk)
      integer    iweigh, maxsub, maxcby, neval, nsubin, iord(*),        &
     &           nnlog(*)
      real       f, a, b, omega, errabs, errrel, result, errest,        &
     &           alist(*), blist(*), rlist(*), elist(*), wk(*)
      external   f
      end

      interface to subroutine qdawf (f, a, iweigh, omega, errabs,       &
     &           result, errest)
      integer    iweigh
      real       f, a, omega, errabs, result, errest
      external   f
      end

      interface to subroutine q2awf (f, a, iweigh, omega, errabs,       &
     &           result, errest, maxcyl, maxsub, maxcby, neval, ncycle, &
     &           rslist, erlist, ierlst, nsubin, wk, iwk)
      integer    iweigh, maxcyl, maxsub, maxcby, neval, ncycle,         &
     &           nsubin, ierlst(*), iwk(2,*)
      real       f, a, omega, errabs, result, errest, rslist(*),        &
     &           erlist(*), wk(*)
      external   f
      end

      interface to subroutine qdaws (f, a, b, iweigh, alpha, beta,      &
     &           errabs, errrel, result, errest)
      integer    iweigh
      real       f, a, b, alpha, beta, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2aws (f, a, b, iweigh, alpha, beta,      &
     &           errabs, errrel, result, errest, maxsub, neval, nsubin, &
     &           alist, blist, rlist, elist, iord)
      integer    iweigh, maxsub, neval, nsubin, iord(*)
      real       f, a, b, alpha, beta, errabs, errrel, result, errest,  &
     &           alist(*), blist(*), rlist(*), elist(*)
      external   f
      end

      interface to subroutine qdawc (f, a, b, c, errabs, errrel, result,&
     &           errest)
      real       f, a, b, c, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2awc (f, a, b, c, errabs, errrel, result,&
     &           errest, maxsub, neval, nsubin, alist, blist, rlist,    &
     &           elist, iord)
      integer    maxsub, neval, nsubin, iord(*)
      real       f, a, b, c, errabs, errrel, result, errest, alist(*),  &
     &           blist(*), rlist(*), elist(*)
      external   f
      end

      interface to subroutine qdng (f, a, b, errabs, errrel, result,    &
     &           errest)
      real       f, a, b, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine twodq (f, a, b, g, h, errabs, errrel,     &
     &           irule, result, errest)
      integer    irule
      real       f, a, b, g, h, errabs, errrel, result, errest
      external   f, g, h
      end

      interface to subroutine t2odq (user, a, b, g, h, errabs, errrel,  &
     &           irule, result, errest, maxsub, neval, nsubin, alist,   &
     &           blist, rlist, elist, iord, wk, iwk)
      integer    irule, maxsub, neval, nsubin, iord(*), iwk(*)
      real       user, a, b, g, h, errabs, errrel, result, errest,      &
     &           alist(*), blist(*), rlist(*), elist(*), wk(*)
      external   user, g, h
      end

      interface to subroutine qand (f, n, a, b, errabs, errrel, maxfcn, &
     &           result, errest)
      integer    n, maxfcn
      real       f, errabs, errrel, result, errest, a(*), b(*)
      external   f
      end

      interface to subroutine gqrul (n, iweigh, alpha, beta, nfix,      &
     &           qxfix, qx, qw)
      integer    n, iweigh, nfix
      real       alpha, beta, qxfix(*), qx(*), qw(*)
      end

      interface to subroutine g2rul (n, iweigh, alpha, beta, nfix,      &
     &           qxfix, qx, qw, wk)
      integer    n, iweigh, nfix
      real       alpha, beta, qxfix(*), qx(*), qw(*), wk(*)
      end

      interface to subroutine gqrcf (n, b, c, nfix, qxfix, qx, qw)
      integer    n, nfix
      real       b(*), c(*), qxfix(*), qx(*), qw(*)
      end

      interface to subroutine g2rcf (n, b, c, nfix, qxfix, qx, qw, wk)
      integer    n, nfix
      real       b(*), c(*), qxfix(*), qx(*), qw(*), wk(*)
      end

      interface to subroutine reccf (n, iweigh, alpha, beta, b, c)
      integer    n, iweigh
      real       alpha, beta, b(*), c(*)
      end

      interface to subroutine recqr (n, qx, qw, nterm, b, c)
      integer    n, nterm
      real       qx(*), qw(*), b(*), c(*)
      end

      interface to subroutine r2cqr (n, qx, qw, nterm, b, c, wk)
      integer    n, nterm
      real       qx(*), qw(*), b(*), c(*), wk(2,*)
      end

      interface to subroutine fqrul (n, a, b, iweigh, alpha, beta, qx,  &
     &           qw)
      integer    n, iweigh
      real       a, b, alpha, beta, qx(*), qw(*)
      end

      interface to subroutine f2rul (n, a, b, iweigh, alpha, beta, qx,  &
     &           qw, wk)
      integer    n, iweigh
      real       a, b, alpha, beta, qx(*), qw(*), wk(*)
      end

      interface to real function deriv (fcn, korder, x, bgstep, tol)
      integer    korder
      real       fcn, x, bgstep, tol
      external   fcn
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine qdags (f, a, b, errabs, errrel, result,   &
     &           errest)
      real       f, a, b, errabs, errrel, result, errest
      external   f
      end

      interface to subroutine q2ags (f, a, b, errabs, errrel, result,   &
     &           errest, maxsub, neval, nsubin, alist, blist, rlist,    &
     &           elist, iord)
      integer    maxsub, neval, nsubin, iord(*)
      real       f, a, b, errabs, errrel, result, errest, alist(*),     &
     &           blist(*), rlist(*), elist(*)
      external   f
      end

$ENDIF

!
!     Chapter 5:  Differential Equations
!

      interface to subroutine ivprk (ido, neq, fcn, x, xend, tol, param,&
     &           y)
      integer    ido, neq
      real       x, xend, tol, param(*), y(*)
      external   fcn
      end

      interface to subroutine i2prk (ido, neq, fcn, x, xend, tol, param,&
     &           y, vnorm, wk)
      integer    ido, neq
      real       x, xend, tol, param(*), y(*), wk(neq,*)
      external   fcn, vnorm
      end

      interface to subroutine i3prk (neq, v, y, ymax, enorm)
      integer    neq
      real       enorm, v(*), y(*), ymax(*)
      end

      interface to subroutine ivpag (ido, neq, fcn, fcnj, a, x, xend,   &
     &           tol, param, y)
      integer    ido, neq
      real       x, xend, tol, a(*), param(*), y(*)
      external   fcn, fcnj
      end

      interface to subroutine i2pag (ido, neq, fcn, fcnj, a, x, xend,   &
     &           tol, param, y, ytemp, ymax, error, save1, save2, pw,   &
     &           ipvt, vnorm)
      integer    ido, neq, ipvt(*)
      real       x, xend, tol, a(*), param(*), y(*), ytemp(*),          &
     &           ymax(*), error(*), save1(*), save2(*), pw(*)
      external   fcn, fcnj, vnorm
      end

      interface to subroutine bvpfd (fcneqn, fcnjac, fcnbc, fcnpeq,     &
     &           fcnpbc, neqns, nleft, ncupbc, xleft, xright, pistep,   &
     &           tol, ninit, xinit, yinit, ldyini, linear, print,       &
     &           mxgrid, nfinal, xfinal, yfinal, ldyfin, errest)
      integer    neqns, nleft, ncupbc, ninit, ldyini, mxgrid, nfinal,   &
     &           ldyfin
      real       xleft, xright, pistep, tol, xinit(*),                  &
     &           yinit(ldyini,*), xfinal(*), yfinal(ldyfin,*),          &
     &           errest(*)
      logical    linear, print
      external   fcneqn, fcnjac, fcnbc, fcnpeq, fcnpbc
      end

      interface to subroutine b2pfd (fcneqn, fcnjac, fcnbc, fcnpeq,     &
     &           fcnpbc, neqns, nleft, ncupbc, xleft, xright, pistep,   &
     &           tol, ninit, xinit, yinit, ldyini, linear, print,       &
     &           mxgrid, nfinal, xfinal, yfinal, ldyfin, errest, rwork, &
     &           iwork)
      integer    neqns, nleft, ncupbc, ninit, ldyini, mxgrid, nfinal,   &
     &           ldyfin, iwork(*)
      real       xleft, xright, pistep, tol, xinit(*),                  &
     &           yinit(ldyini,*), xfinal(*), yfinal(ldyfin,*),          &
     &           errest(*), rwork(*)
      logical    linear, print
      external   fcneqn, fcnjac, fcnbc, fcnpeq, fcnpbc
      end

      interface to subroutine bvpms (fcneqn, fcnjac, fcnbc, neqns,      &
     &           xleft, xright, dtol, btol, maxit, ninit, xinit, yinit, &
     &           ldyini, nmax, nfinal, xfinal, yfinal, ldyfin)
      integer    neqns, maxit, ninit, ldyini, nmax, nfinal, ldyfin
      real       xleft, xright, dtol, btol, xinit(*), yinit(ldyini,*),  &
     &           xfinal(*), yfinal(ldyfin,*)
      external   fcneqn, fcnjac, fcnbc
      end

      interface to subroutine b2pms (fcneqn, fcnjac, fcnbc, neqns,      &
     &           xleft, xright, dtol, btol, maxit, ninit, xinit, yinit, &
     &           ldyini, nmax, nfinal, xfinal, yfinal, ldyfin, work,    &
     &           iwk)
      integer    neqns, maxit, ninit, ldyini, nmax, nfinal, ldyfin,     &
     &           iwk(*)
      real       xleft, xright, dtol, btol, xinit(*), yinit(ldyini,*),  &
     &           xfinal(*), yfinal(ldyfin,*), work(*)
      external   fcneqn, fcnjac, fcnbc
      end

      interface to subroutine daspg (neq, t, tout, ido, y, yprime,      &
     &           dgspg)
      integer    neq, ido
      real       t, tout, y(*), yprime(*)
      external   dgspg
      end

      interface to subroutine d2spg (neq, t, tout, ido, y, yprime,      &
     &           dgspg, djspg, iwork, rwork)
      integer    neq, ido, iwork(*)
      real       t, tout, y(*), yprime(*), rwork(*)
      external   dgspg, djspg
      end

      interface to subroutine dgspg (n, t, y, ypr, gval)
      integer    n
      real       t, y(n), ypr(n), gval(n)
      end

      interface to subroutine djspg (n, t, y, ypr, cj, pdg, ldpdg)
      integer    n, ldpdg
      real       t, cj, y(n), ypr(n), pdg(ldpdg*n)
      end

      interface to subroutine molch (ido, fcnut, fcnbc, npdes, t, tend, &
     &           nx, xbreak, tol, hinit, y, ldy)
      integer    ido, npdes, nx, ldy
      real       t, tend, tol, hinit, xbreak(*), y(ldy,*)
      external   fcnut, fcnbc
      end

      interface to subroutine m2lch (ido, fcnut, fcnbc, npdes, t, tend, &
     &           nx, xbreak, tol, hinit, y, ldy, wk, iwk)
      integer    ido, npdes, nx, ldy, iwk(*)
      real       t, tend, tol, hinit, xbreak(*), y(ldy,*), wk(*)
      external   fcnut, fcnbc
      end

      interface to subroutine fps2h (prhs, brhs, coefu, nx, ny, ax, bx, &
     &           ay, by, ibcty, iorder, u, ldu)
      integer    nx, ny, iorder, ldu, ibcty(*)
      real       prhs, brhs, coefu, ax, bx, ay, by, u(ldu,*)
      external   prhs, brhs
      end

      interface to subroutine f2s2h (prhs, brhs, coefu, nx, ny, ax, bx, &
     &           ay, by, ibcty, iorder, u, ldu, uwork, work)
      integer    nx, ny, iorder, ldu, ibcty(*)
      real       coefu, ax, bx, ay, by, u(ldu,*), uwork(*), work(*),    &
     &           prhs, brhs
      external   prhs, brhs
      end

      interface to subroutine fps3h (prhs, brhs, coefu, nx, ny, nz, ax, &
     &           bx, ay, by, az, bz, ibcty, iorder, u, ldu, mdu)
      integer    nx, ny, nz, iorder, ldu, mdu, ibcty(*)
      real       prhs, brhs, coefu, ax, bx, ay, by, az, bz,             &
     &           u(ldu,mdu,*)
      external   prhs, brhs
      end

      interface to subroutine f2s3h (prhs, brhs, coefu, nx, ny, nz, ax, &
     &           bx, ay, by, az, bz, ibcty, iorder, u, ldu, mdu, uwork, &
     &           work)
      integer    nx, ny, nz, iorder, ldu, mdu, ibcty(*)
      real       prhs, brhs, coefu, ax, bx, ay, by, az, bz,             &
     &           u(ldu,mdu,*), uwork(*), work(*)
      external   prhs, brhs
      end

!
!     Chapter 6:  Transforms
!

      interface to subroutine fftcf (n, seq, coef)
      integer    n
      complex    seq(*), coef(*)
      end

      interface to subroutine f2tcf (n, seq, coef, wfftc, cpy)
      integer    n
      real       wfftc(*), cpy(*)
      complex    seq(*), coef(*)
      end

      interface to subroutine fftcb (n, coef, seq)
      integer    n
      complex    coef(*), seq(*)
      end

      interface to subroutine f2tcb (n, coef, seq, wfftc, cpy)
      integer    n
      real       wfftc(*), cpy(*)
      complex    coef(*), seq(*)
      end

      interface to subroutine fftci (n, wfftc)
      integer    n
      real       wfftc(*)
      end

      interface to subroutine fsint (n, seq, coef)
      integer    n
      real       seq(*), coef(*)
      end

      interface to subroutine f2int (n, seq, coef, wfsin)
      integer    n
      real       seq(*), coef(*), wfsin(*)
      end

      interface to subroutine fsini (n, wfsin)
      integer    n
      real       wfsin(*)
      end

      interface to subroutine fcost (n, seq, coef)
      integer    n
      real       seq(*), coef(*)
      end

      interface to subroutine f2ost (n, seq, coef, wfcos)
      integer    n
      real       seq(*), coef(*), wfcos(*)
      end

      interface to subroutine fcosi (n, wfcos)
      integer    n
      real       wfcos(*)
      end

      interface to subroutine qsinf (n, seq, coef)
      integer    n
      real       seq(*), coef(*)
      end

      interface to subroutine q2inf (n, seq, coef, wqsin)
      integer    n
      real       seq(*), coef(*), wqsin(*)
      end

      interface to subroutine qsinb (n, coef, seq)
      integer    n
      real       coef(*), seq(*)
      end

      interface to subroutine q2inb (n, coef, seq, wqsin)
      integer    n
      real       coef(*), seq(*), wqsin(*)
      end

      interface to subroutine qsini (n, wqsin)
      integer    n
      real       wqsin(*)
      end

      interface to subroutine qcosf (n, seq, coef)
      integer    n
      real       seq(*), coef(*)
      end

      interface to subroutine q2osf (n, seq, coef, wqcos)
      integer    n
      real       seq(*), coef(*), wqcos(*)
      end

      interface to subroutine qcosb (n, coef, seq)
      integer    n
      real       coef(*), seq(*)
      end

      interface to subroutine q2osb (n, coef, seq, wqcos)
      integer    n
      real       coef(*), seq(*), wqcos(*)
      end

      interface to subroutine qcosi (n, wqcos)
      integer    n
      real       wqcos(*)
      end

      interface to subroutine fft2d (nra, nca, a, lda, coef, ldcoef)
      integer    nra, nca, lda, ldcoef
      complex    a(lda,*), coef(ldcoef,*)
      end

      interface to subroutine f2t2d (nra, nca, a, lda, coef, ldcoef,    &
     &           wff1, wff2, cwk, cpy)
      integer    nra, nca, lda, ldcoef
      real       wff1(*), wff2(*), cpy(*)
      complex    a(lda,*), coef(ldcoef,*), cwk(*)
      end

      interface to subroutine fft2b (nrcoef, nccoef, coef, ldcoef, a,   &
     &           lda)
      integer    nrcoef, nccoef, ldcoef, lda
      complex    coef(ldcoef,*), a(lda,*)
      end

      interface to subroutine f2t2b (nrcoef, nccoef, a, lda, coef,      &
     &           ldcoef, wff1, wff2, cwk, cpy)
      integer    nrcoef, nccoef, lda, ldcoef
      real       wff1(*), wff2(*), cpy(*)
      complex    a(lda,*), coef(ldcoef,*), cwk(*)
      end

      interface to subroutine fft3f (n1, n2, n3, a, lda, mda, b, ldb,   &
     &           mdb)
      integer    n1, n2, n3, lda, mda, ldb, mdb
      complex    a(*), b(*)
      end

      interface to subroutine f2t3f (n1, n2, n3, a, lda, mda, b, ldb,   &
     &           mdb, wff1, wff2, wff3, cpy)
      integer    lda, mda, ldb, mdb, n1, n2, n3
      real       wff1(*), wff2(*), wff3(*), cpy(*)
      complex    a(lda,mda,*), b(lda,mda,*)
      end

      interface to subroutine fft3b (n1, n2, n3, a, lda, mda, b, ldb,   &
     &           mdb)
      integer    n1, n2, n3, lda, mda, ldb, mdb
      complex    a(*), b(*)
      end

      interface to subroutine f2t3b (n1, n2, n3, a, lda, mda, b, ldb,   &
     &           mdb, wff1, wff2, wff3, cpy)
      integer    n1, n2, n3, lda, mda, ldb, mdb
      real       wff1(*), wff2(*), wff3(*), cpy(*)
      complex    a(lda,mda,*), b(lda,mda,*)
      end

      interface to subroutine rconv (ido, nx, x, ny, y, ipad, nz, z,    &
     &           zhat)
      integer    ido, nx, ny, ipad, nz
      real       x(*), y(*), z(*), zhat(*)
      end

      interface to subroutine r2onv (ido, nx, x, ny, y, ipad, nz, z,    &
     &           zhat, xwk, ywk, wk)
      integer    ido, nx, ny, ipad, nz
      real       x(*), y(*), z(*), zhat(*), xwk(*), ywk(*), wk(*)
      end

      interface to subroutine cconv (ido, nx, x, ny, y, ipad, nz, z,    &
     &           zhat)
      integer    ido, nx, ny, ipad, nz
      complex    x(*), y(*), z(*), zhat(*)
      end

      interface to subroutine c2onv (ido, nx, x, ny, y, ipad, nz, z,    &
     &           zhat, xwk, ywk, wk)
      integer    ido, nx, ny, ipad, nz
      real       wk(*)
      complex    x(*), y(*), z(*), zhat(*), xwk(*), ywk(*)
      end

      interface to subroutine rcorl (ido, n, x, y, ipad, nz, z, zhat)
      integer    ido, n, ipad, nz
      real       x(*), y(*), z(*), zhat(*)
      end

      interface to subroutine r2orl (ido, n, x, y, ipad, nz, z, zhat,   &
     &           xwk, ywk, wk)
      integer    n, ipad, ido, nz
      real       x(*), y(*), z(*), zhat(*), xwk(*), ywk(*), wk(*)
      end

      interface to subroutine ccorl (ido, n, x, y, ipad, nz, z, zhat)
      integer    ido, n, ipad, nz
      complex    x(*), y(*), z(*), zhat(*)
      end

      interface to subroutine c2orl (ido, n, x, y, ipad, nz, z, zhat,   &
     &           xwk, ywk, wk)
      integer    ido, n, ipad, nz
      real       wk(*)
      complex    x(*), y(*), z(*), zhat(*), xwk(*), ywk(*)
      end

      interface to subroutine inlap (f, n, t, alpha, relerr, kmax, finv)
      integer    n, kmax
      real       alpha, relerr, t(*), finv(*)
      complex    f
      external   f
      end

      interface to subroutine sinlp (f, n, t, sigma0, epstol, errvec,   &
     &           finv)
      integer    n
      real       sigma0, epstol, t(*), errvec(*), finv(*)
      complex    f
      external   f
      end

      interface to subroutine s2nlp (f, n, t, sigma0, epstol, errvec,   &
     &           finv, sigma, bvalue, mtop, wk, iflovc)
      integer    n, mtop, iflovc(*)
      real       sigma0, epstol, sigma, bvalue, t(*), errvec(*),        &
     &           finv(*), wk(*)
      complex    f
      external   f
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine fftrf (n, seq, coef)
      integer    n
      real       seq(*), coef(*)
      end

      interface to subroutine f2trf (n, seq, coef, wfftr)
      integer    n
      real       seq(*), coef(*), wfftr(*)
      end

      interface to subroutine fftrb (n, coef, seq)
      integer    n
      real       coef(*), seq(*)
      end

      interface to subroutine f2trb (n, coef, seq, wfftr)
      integer    n
      real       coef(*), seq(*), wfftr(*)
      end

      interface to subroutine fftri (n, wfftr)
      integer    n
      real       wfftr(*)
      end

$ENDIF

!
!     Chapter 7:  Nonlinear Equations
!

      interface to subroutine zplrc (ndeg, coeff, root)
      integer    ndeg
      real       coeff(*)
      complex    root(*)
      end

      interface to subroutine zporc (ndeg, coeff, root)
      integer    ndeg
      real       coeff(*)
      complex    root(*)
      end

      interface to subroutine zpocc (ndeg, coeff, root)
      integer    ndeg
      complex    coeff(*), root(*)
      end

      interface to subroutine zanly (f, errabs, errrel, nknown, nnew,   &
     &           nguess, xinit, itmax, x, infer)
      integer    nknown, nnew, nguess, itmax, infer(*)
      real       errabs, errrel
      complex    f, xinit(*), x(*)
      external   f
      end

      interface to subroutine zbren (f, errabs, errrel, a, b, maxfn)
      integer    maxfn
      real       f, errabs, errrel, a, b
      external   f
      end

      interface to subroutine zreal (f, errabs, errrel, eps, eta, nroot,&
     &           itmax, xguess, x, infer)
      integer    nroot, itmax, infer(*)
      real       f, errabs, errrel, eps, eta, xguess(*), x(*)
      external   f
      end

      interface to subroutine neqnf (fcn, errrel, n, itmax, xinit, x,   &
     &           fnorm)
      integer    n, itmax
      real       errrel, fnorm, xinit(*), x(*)
      external   fcn
      end

      interface to subroutine n2qnf (fcn, errrel, n, itmax, xinit, x,   &
     &           fnorm, fvec, fjac, r, qtf, wk)
      integer    n, itmax
      real       errrel, fnorm, xinit(*), x(*), fvec(*), fjac(n,*),     &
     &           r(*), qtf(*), wk(*)
      external   fcn
      end

      interface to subroutine neqnj (fcn, lsjac, errrel, n, itmax,      &
     &           xinit, x, fnorm)
      integer    n, itmax
      real       errrel, fnorm, xinit(*), x(*)
      external   fcn, lsjac
      end

      interface to subroutine n2qnj (fcn, lsjac, errrel, n, itmax,      &
     &           xinit, x, fnorm, fvec, fjac, r, qtf, wk)
      integer    n, itmax
      real       errrel, fnorm, xinit(*), x(*), fvec(*), fjac(n,*),     &
     &           r(*), qtf(*), wk(*)
      external   fcn, lsjac
      end

      interface to subroutine neqbf (fcn, n, xguess, xscale, fscale,    &
     &           iparam, rparam, x, fvec)
      integer    n, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*)
      external   fcn
      end

      interface to subroutine n2qbf (fcn, n, xguess, xscale, fscale,    &
     &           iparam, rparam, x, fvec, wk, lwk)
      integer    n, lwk, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), wk(*)
      external   fcn
      end

      interface to subroutine neqbj (fcn, jac, n, xguess, xscale,       &
     &           fscale, iparam, rparam, x, fvec)
      integer    n, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*)
      external   fcn, jac
      end

      interface to subroutine n2qbj (fcn, jac, n, xguess, xscale,       &
     &           fscale, iparam, rparam, x, fvec, wk, lwk)
      integer    n, lwk, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), wk(*)
      external   fcn, jac
      end

      interface to subroutine n4qbj (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

!
!     Chapter 8:  Optimization
!

      interface to subroutine uvmif (f, xguess, step, bound, xacc,      &
     &           maxfn, x)
      integer    maxfn
      real       f, xguess, step, bound, xacc, x
      end

      interface to subroutine uvmid (f, g, xguess, errrel, gtol, maxfn, &
     &           a, b, x, fx, gx)
      integer    maxfn
      real       f, g, xguess, errrel, gtol, a, b, x, fx, gx
      external   f, g
      end

      interface to subroutine uvmgs (f, a, b, tol, xmin)
      real       f, a, b, tol, xmin
      external   f
      end

      interface to subroutine uming (fcn, grad, n, xguess, xscale,      &
     &           fscale, iparam, rparam, x, fvalue)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*), x(*)
      external   fcn, grad
      end

      interface to subroutine u2ing (fcn, grad, n, xguess, xscale,      &
     &           fscale, iparam, rparam, x, fvalue, wk)
      integer    n, iparam(*)
      real       xguess(*), fscale, fvalue, xscale(*), rparam(*),       &
     &           x(*), wk(*)
      external   fcn, grad
      end

      interface to subroutine umidh (fcn, grad, n, xguess, xscale,      &
     &           fscale, iparam, rparam, x, fvalue)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*), x(*)
      external   fcn, grad
      end

      interface to subroutine u2idh (fcn, grad, n, xguess, xscale,      &
     &           fscale, iparam, rparam, x, fvalue, wk)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*),       &
     &           x(*), wk(*)
      external   fcn, grad
      end

      interface to subroutine umiah (fcn, grad, hess, n, xguess, xscale,&
     &           fscale, iparam, rparam, x, fvalue)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*), x(*)
      external   fcn, grad, hess
      end

      interface to subroutine u2iah (fcn, grad, hess, n, xguess, xscale,&
     &           fscale, iparam, rparam, x, fvalue, wk)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*),       &
     &           x(*), wk(*)
      external   fcn, grad, hess
      end

      interface to subroutine umcgf (fcn, n, xguess, xscale, gradtl,    &
     &           maxfn, dfpred, x, g, fvalue)
      integer    n, maxfn
      real       gradtl, dfpred, fvalue, xguess(*), xscale(*), x(*),    &
     &           g(*)
      external   fcn
      end

      interface to subroutine u2cgf (fcn, n, xguess, xscale, gradtl,    &
     &           maxfn, dfpred, x, g, fvalue, s, rss, rsg, ginit, xopt, &
     &           gopt)
      integer    n, maxfn
      real       gradtl, dfpred, fvalue, xguess(*), xscale(*), x(*),    &
     &           g(*), s(*), rss(*), rsg(*), ginit(*), xopt(*), gopt(*)
      external   fcn
      end

      interface to subroutine umcgg (fcn, grad, n, xguess, gradtl,      &
     &           maxfn, dfpred, x, g, fvalue)
      integer    n, maxfn
      real       gradtl, dfpred, fvalue, xguess(*), x(*), g(*)
      external   fcn, grad
      end

      interface to subroutine u2cgg (fcn, grad, n, xguess, gradtl,      &
     &           maxfn, dfpred, x, g, fvalue, s, rss, rsg, ginit, xopt, &
     &           gopt)
      integer    n, maxfn
      real       gradtl, dfpred, fvalue, xguess(*), x(*), g(*), s(*),   &
     &           rss(*), rsg(*), ginit(*), xopt(*), gopt(*)
      external   fcn, grad
      end

      interface to subroutine umpol (fcn, n, xguess, s, ftol, maxfcn, x,&
     &           fvalue)
      integer    n, maxfcn
      real       s, ftol, fvalue, xguess(*), x(*)
      external   fcn
      end

      interface to subroutine u2pol (fcn, n, xguess, s, ftol, maxfcn, x,&
     &           fvalue, wk)
      integer    n, maxfcn
      real       s, ftol, fvalue, xguess(*), x(*), wk(*)
      external   fcn
      end

      interface to subroutine unlsf (fcn, m, n, xguess, xscale, fscale, &
     &           iparam, rparam, x, fvec, fjac, ldfjac)
      integer    m, n, ldfjac, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), fjac(*)
      external   fcn
      end

      interface to subroutine u2lsf (fcn, m, n, xguess, xscale, fscale, &
     &           iparam, rparam, x, fvec, fjac, ldfjac, wk, iwk)
      integer    m, n, ldfjac, iparam(*), iwk(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), fjac(*), wk(*)
      external   fcn
      end

      interface to subroutine u4lsf (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

      interface to subroutine unlsj (fcn, jac, m, n, xguess, xscale,    &
     &           fscale, iparam, rparam, x, fvec, fjac, ldfjac)
      integer    m, n, ldfjac, iparam(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), fjac(ldfjac,*)
      external   fcn, jac
      end

      interface to subroutine u2lsj (fcn, jac, m, n, xguess, xscale,    &
     &           fscale, iparam, rparam, x, fvec, fjac, ldfjac, wk, iwk)
      integer    m, n, ldfjac, iparam(*), iwk(*)
      real       xguess(*), xscale(*), fscale(*), rparam(*), x(*),      &
     &           fvec(*), fjac(ldfjac,*), wk(*)
      external   fcn, jac
      end

      interface to subroutine bconf (fcn, n, xguess, ibtype, xlb, xub,  &
     &           xscale, fscale, iparam, rparam, x, fvalue)
      integer    n, ibtype, iparam(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*)
      external   fcn
      end

      interface to subroutine b2onf (fcn, n, xguess, ibtype, xlb, xub,  &
     &           xscale, fscale, iparam, rparam, x, fvalue, wk, iwk)
      integer    n, ibtype, iparam(*), iwk(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*), wk(*)
      external   fcn
      end

      interface to subroutine bcong (fcn, grad, n, xguess, ibtype, xlb, &
     &           xub, xscale, fscale, iparam, rparam, x, fvalue)
      integer    n, ibtype, iparam(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*)
      external   fcn, grad
      end

      interface to subroutine b2ong (fcn, grad, n, xguess, ibtype, xlb, &
     &           xub, xscale, fscale, iparam, rparam, x, fvalue, wk,    &
     &           iwk)
      integer    n, ibtype, iparam(*), iwk(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*), wk(*)
      external   fcn, grad
      end

      interface to subroutine bcodh (fcn, grad, n, xguess, ibtype, xlb, &
     &           xub, xscale, fscale, iparam, rparam, x, fvalue)
      integer    n, ibtype, iparam(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*)
      external   fcn, grad
      end

      interface to subroutine b2odh (fcn, grad, n, xguess, ibtype, xlb, &
     &           xub, xscale, fscale, iparam, rparam, x, fvalue, wk,    &
     &           iwk)
      integer    n, ibtype, iparam(*), iwk(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*), wk(*)
      external   fcn, grad
      end

      interface to subroutine bcoah (fcn, grad, hess, n, xguess, ibtype,&
     &           xlb, xub, xscale, fscale, iparam, rparam, x, fvalue)
      integer    n, ibtype, iparam(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*)
      external   fcn, grad, hess
      end

      interface to subroutine b2oah (fcn, grad, hess, n, xguess, ibtype,&
     &           xlb, xub, xscale, fscale, iparam, rparam, x, fvalue,   &
     &           wk, iwk)
      integer    n, ibtype, iparam(*), iwk(*)
      real       fscale, fvalue, xguess(*), xlb(*), xub(*), xscale(*),  &
     &           rparam(*), x(*), wk(*)
      external   fcn, grad, hess
      end

      interface to subroutine bcpol (fcn, n, xguess, ibtype, xlb, xub,  &
     &           ftol, maxfcn, x, fvalue)
      integer    n, ibtype, maxfcn
      real       ftol, fvalue, xguess(*), xlb(*), xub(*), x(*)
      external   fcn
      end

      interface to subroutine b2pol (fcn, n, xguess, ibtype, xlb, xub,  &
     &           ftol, maxfcn, x, fvalue, wk)
      integer    n, ibtype, maxfcn
      real       ftol, fvalue, xguess(*), xlb(*), xub(*), x(*), wk(*)
      external   fcn
      end

      interface to subroutine bclsf (fcn, m, n, xguess, ibtype, xlb,    &
     &           xub, xscale, fscale, iparam, rparam, x, fvec, fjac,    &
     &           ldfjac)
      integer    m, n, ibtype, ldfjac, iparam(*)
      real       xguess(*), xlb(*), xub(*), xscale(*), fscale(*),       &
     &           rparam(*), x(*), fvec(*), fjac(ldfjac,*)
      external   fcn
      end

      interface to subroutine b2lsf (fcn, m, n, xguess, ibtype, xlb,    &
     &           xub, xscale, fscale, iparam, rparam, x, fvec, fjac,    &
     &           ldfjac, wk, iwk)
      integer    m, n, ibtype, ldfjac, iparam(*), iwk(*)
      real       xguess(*), xlb(*), xub(*), xscale(*), fscale(*),       &
     &           rparam(*), x(*), fvec(*), fjac(*), wk(*)
      external   fcn
      end

      interface to subroutine bclsj (fcn, jac, m, n, xguess, ibtype,    &
     &           xlb, xub, xscale, fscale, iparam, rparam, x, fvec,     &
     &           fjac, ldfjac)
      integer    m, n, ibtype, ldfjac, iparam(*)
      real       xguess(*), xlb(*), xub(*), xscale(*), fscale(*),       &
     &           rparam(*), x(*), fvec(*), fjac(ldfjac,*)
      external   fcn, jac
      end

      interface to subroutine b2lsj (fcn, jac, m, n, xguess, ibtype,    &
     &           xlb, xub, xscale, fscale, iparam, rparam, x, fvec,     &
     &           fjac, ldfjac, wk, iwk)
      integer    m, n, ibtype, ldfjac, iparam(*), iwk(*)
      real       xguess(*), xlb(*), xub(*), xscale(*), fscale(*),       &
     &           rparam(*), x(*), fvec(*), fjac(ldfjac,*), wk(*)
      external   fcn, jac
      end

      interface to subroutine dlprs (m, nvar, a, lda, bl, bu, c, irtype,&
     &           xlb, xub, obj, xsol, dsol)
      integer    m, nvar, lda, irtype(*)
      real       obj, a(lda,*), bl(*), bu(*), c(*), xlb(*), xub(*),     &
     &           xsol(*), dsol(*)
      end

      interface to subroutine d2prs (m, nvar, a, lda, bl, bu, c, irtype,&
     &           xlb, xub, obj, xsol, dsol, awk, ldawk, wk, iwk)
      integer    m, nvar, lda, ldawk, irtype(*), iwk(*)
      real       obj, a(lda,*), bl(*), bu(*), c(*), xlb(*), xub(*),     &
     &           xsol(*), dsol(*), awk(*), wk(*)
      end

      interface to subroutine qprog (nvar, ncon, neq, a, lda, b, g, h,  &
     &           ldh, diag, sol, nact, iact, alamda)
      integer    nvar, ncon, neq, lda, ldh, nact, iact(*)
      real       diag, a(lda,*), b(*), g(*), h(ldh,*), sol(*),          &
     &           alamda(*)
      end

      interface to subroutine q2rog (nvar, ncon, neq, a, lda, b, grad,  &
     &           h, ldh, diag, sol, nact, iact, alamda, wk)
      integer    nvar, ncon, neq, lda, ldh, nact, iact(*)
      real       diag, a(lda,*), b(*), grad(*), h(ldh,*), sol(*),       &
     &           alamda(*), wk(*)
      end

      interface to subroutine lconf (fcn, nvar, ncon, neq, a, lda, b,   &
     &           xlb, xub, xguess, acc, maxfcn, sol, obj, nact, iact,   &
     &           alamda)
      integer    nvar, ncon, neq, lda, maxfcn, nact, iact(*)
      real       acc, obj, a(lda,*), b(*), xlb(*), xub(*), xguess(*),   &
     &           sol(*), alamda(*)
      external   fcn
      end

      interface to subroutine l2onf (fcn, n, m, meq, a, ia, b, xl, xu,  &
     &           x, acc, maxfcn, sol, obj, nact, iact, par, iprint,     &
     &           info, w)
      integer    n, m, meq, ia, maxfcn, nact, iprint, info, iact(*)
      real       acc, obj, a(ia,*), b(*), xl(*), xu(*), x(*), sol(*),   &
     &           par(*), w(*)
      external   fcn
      end

      interface to subroutine lcong (fcn, grad, nvar, ncon, neq, a, lda,&
     &           b, xlb, xub, xguess, acc, maxfcn, sol, obj, nact, iact,&
     &           alamda)
      integer    nvar, ncon, neq, lda, maxfcn, nact, iact(*)
      real       acc, obj, a(lda,*), b(*), xlb(*), xub(*), xguess(*),   &
     &           sol(*), alamda(*)
      external   fcn, grad
      end

      interface to subroutine l2ong (fcn, grad, n, m, meq, a, ia, b, xl,&
     &           xu, x, acc, maxfcn, sol, obj, nact, iact, par, iprint, &
     &           info, w)
      integer    n, m, meq, ia, maxfcn, nact, iprint, info, iact(*)
      real       acc, obj, a(ia,*), b(*), xl(*), xu(*), x(*), sol(*),   &
     &           par(*), w(*)
      external   fcn, grad
      end

      interface to subroutine nconf (fcn, m, me, n, xguess, ibtype, xlb,&
     &           xub, xscale, iprint, maxitn, x, fvalue)
      integer    m, me, n, ibtype, iprint, maxitn
      real       fvalue, xguess(*), xlb(*), xub(*), xscale(*), x(*)
      external   fcn
      end

      interface to subroutine n2onf (fcns, m, me, n, xguess, ibtype,    &
     &           xlb, xub, xscale, iprint, maxitn, x, fvalue, wk, lwk,  &
     &           iwk, liwk, conwk)
      integer    m, me, n, ibtype, iprint, maxitn, lwk, liwk, iwk(*)
      real       fvalue, xguess(*), xlb(*), xub(*), xscale(*), x(*),    &
     &           wk(*), conwk(*)
      external   fcns
      end

      interface to subroutine n0onf (ido, m, me, n, ibtype, xlb, xub,   &
     &           iprint, maxitn, x, fvalue, g, df, dg, lddg, u, c, ldc, &
     &           d, acc, scbou, maxfun, active, mode, wk, iwk, conwk)
      integer    ido, m, me, n, ibtype, iprint, maxitn, lddg, ldc,      &
     &           maxfun, mode, iwk(*)
      real       fvalue, acc, scbou, xlb(*), xub(*), x(*), g(*),        &
     &           df(*), dg(lddg,*), u(*), c(ldc,*), d(*), wk(*),        &
     &           conwk(*)
      logical    active(*)
      end

      interface to subroutine ncong (fcn, grad, m, me, n, xguess,       &
     &           ibtype, xlb, xub, iprint, maxitn, x, fvalue)
      integer    m, me, n, ibtype, iprint, maxitn
      real       fvalue, xguess(*), xlb(*), xub(*), x(*)
      external   fcn, grad
      end

      interface to subroutine n2ong (fcns, grad, m, me, n, xguess,      &
     &           ibtype, xlb, xub, iprint, maxitn, x, fvalue, wk, lwk,  &
     &           iwk, liwk)
      integer    m, me, n, ibtype, iprint, maxitn, lwk, liwk, iwk(*)
      real       fvalue, xguess(*), xlb(*), xub(*), x(*), wk(*)
      external   fcns, grad
      end

      interface to subroutine cdgrd (fcn, n, xc, xscale, epsfcn, gc)
      integer    n
      real       epsfcn, xc(*), xscale(*), gc(*)
      external   fcn
      end

      interface to subroutine fdgrd (fcn, n, xc, xscale, fc, epsfcn, gc)
      integer    n
      real       fc, epsfcn, xc(*), xscale(*), gc(*)
      external   fcn
      end

      interface to subroutine fdhes (fcn, n, xc, xscale, fc, epsfcn, h, &
     &           ldh)
      integer    n, ldh
      real       fc, epsfcn, xc(*), xscale(*), h(ldh,*)
      external   fcn
      end

      interface to subroutine f2hes (fcn, n, xc, xscale, fc, epsfcn, h, &
     &           ldh, stepsz, fneibr)
      integer    n, ldh
      real       fc, epsfcn, xc(*), xscale(*), h(ldh,*), stepsz(*),     &
     &           fneibr(*)
      external   fcn
      end

      interface to subroutine gdhes (grad, n, xc, xscale, gc, epsfcn, h,&
     &           ldh)
      integer    n, ldh
      real       epsfcn, xc(*), xscale(*), gc(*), h(ldh,*)
      external   grad
      end

      interface to subroutine g2hes (grad, n, xc, xscale, gc, epsfcn, h,&
     &           ldh, wk)
      integer    n, ldh
      real       epsfcn, xc(*), xscale(*), gc(*), h(ldh,*), wk(*)
      external   grad
      end

      interface to subroutine fdjac (fcn, m, n, xc, xscale, fc, epsfcn, &
     &           fjac, ldfjac)
      integer    m, n, ldfjac
      real       epsfcn, xc(*), xscale(*), fc(*), fjac(ldfjac,*)
      external   fcn
      end

      interface to subroutine f2jac (fcn, m, n, xc, xscale, fc, epsfcn, &
     &           fjac, ldfjac, work)
      integer    m, n, ldfjac
      real       epsfcn, xc(*), xscale(*), fc(*), fjac(ldfjac,*),       &
     &           work(*)
      external   fcn
      end

      interface to subroutine chgrd (fcn, grad, n, x, info)
      integer    n, info(*)
      real       grad(*), x(*)
      external   fcn
      end

      interface to subroutine c2grd (fcn, grad, n, x, info, fx, xscale, &
     &           epsfcn, xnew)
      integer    n, info(*)
      real       fx, epsfcn, grad(*), x(*), xscale(*), xnew(*)
      external   fcn
      end

      interface to subroutine chhes (grad, hess, n, x, info, ldinfo)
      integer    n, ldinfo, info(ldinfo,*)
      real       x(*)
      external   grad, hess
      end

      interface to subroutine c2hes (grad, hess, n, x, info, ldinfo, gx,&
     &           hx, hs, xscale, epsfcn, inft, xnew)
      integer    n, ldinfo, info(ldinfo,*), inft(*)
      real       epsfcn, x(*), gx(*), hx(n,*), hs(*), xscale(*),        &
     &           xnew(*)
      external   grad, hess
      end

      interface to subroutine chjac (fcn, jac, m, n, x, info, ldinfo)
      integer    m, n, ldinfo, info(ldinfo,*)
      real       x(*)
      external   fcn, jac
      end

      interface to subroutine c2jac (fcn, jac, m, n, x, info, ldinfo,   &
     &           fx, fjac, grad, xscale, epsfcn, inft, xnew)
      integer    m, n, ldinfo, info(ldinfo,*), inft(*)
      real       epsfcn, x(*), fx(*), fjac(m,*), grad(*), xscale(*),    &
     &           xnew(*)
      external   fcn, jac
      end

      interface to subroutine ggues (n, a, b, k, ido, s)
      integer    n, k, ido
      real       a(*), b(*), s(*)
      end

      interface to subroutine g2ues (n, a, b, k, ido, s, wk, iwk)
      integer    n, k, ido, iwk(*)
      real       a(*), b(*), s(*), wk(*)
      end

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine uminf (fcn, n, xguess, xscale, fscale,    &
     &           iparam, rparam, x, fvalue)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*), x(*)
      external   fcn
      end

      interface to subroutine u2inf (fcn, n, xguess, xscale, fscale,    &
     &           iparam, rparam, x, fvalue, wk)
      integer    n, iparam(*)
      real       fscale, fvalue, xguess(*), xscale(*), rparam(*),       &
     &           x(*), wk(*)
      external   fcn
      end

      interface to subroutine u4inf (iparam, rparam)
      integer    iparam(*)
      real       rparam(*)
      end

$ENDIF

!
!     Chapter 9:  Basic Matrix/Vector Operations
!

      interface to subroutine crgrg (n, a, lda, b, ldb)
      integer    n, lda, ldb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine ccgcg (n, a, lda, b, ldb)
      integer    n, lda, ldb
      complex    a(lda,*), b(ldb,*)
      end

      interface to subroutine crbrb (n, a, lda, nlca, nuca, b, ldb,     &
     &           nlcb, nucb)
      integer    n, lda, nlca, nuca, ldb, nlcb, nucb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine ccbcb (n, a, lda, nlca, nuca, b, ldb,     &
     &           nlcb, nucb)
      integer    n, lda, nlca, nuca, ldb, nlcb, nucb
      complex    a(lda,*), b(ldb,*)
      end

      interface to subroutine crgrb (n, a, lda, nlc, nuc, b, ldb)
      integer    n, lda, nlc, nuc, ldb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine crbrg (n, a, lda, nlc, nuc, b, ldb)
      integer    n, lda, nlc, nuc, ldb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine ccgcb (n, a, lda, nlc, nuc, b, ldb)
      integer    n, lda, nlc, nuc, ldb
      complex    a(lda,*), b(ldb,*)
      end

      interface to subroutine ccbcg (n, a, lda, nlc, nuc, b, ldb)
      integer    n, lda, nlc, nuc, ldb
      complex    a(lda,*), b(ldb,*)
      end

      interface to subroutine crgcg (n, a, lda, b, ldb)
      integer    n, lda, ldb
      real       a(lda,*)
      complex    b(ldb,*)
      end

      interface to subroutine crrcr (nra, nca, a, lda, nrb, ncb, b, ldb)
      integer    nra, nca, lda, nrb, ncb, ldb
      real       a(lda,*)
      complex    b(ldb,*)
      end

      interface to subroutine crbcb (n, a, lda, nlca, nuca, b, ldb,     &
     &           nlcb, nucb)
      integer    n, lda, nlca, nuca, ldb, nlcb, nucb
      real       a(lda,*)
      complex    b(ldb,*)
      end

      interface to subroutine csfrg (n, a, lda)
      integer    n, lda
      real       a(lda,*)
      end

      interface to subroutine chfcg (n, a, lda)
      integer    n, lda
      complex    a(lda,*)
      end

      interface to subroutine csbrb (n, a, lda, nuca, b, ldb, nlcb,     &
     &           nucb)
      integer    n, lda, nuca, ldb, nlcb, nucb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine chbcb (n, a, lda, nuca, b, ldb, nlcb,     &
     &           nucb)
      integer    n, lda, nuca, ldb, nlcb, nucb
      complex    a(lda,*), b(ldb,*)
      end

      interface to subroutine mxytf (nra, nca, a, lda, nrb, ncb, b, ldb,&
     &           nrc, ncc, c, ldc)
      integer    nra, nca, lda, nrb, ncb, ldb, nrc, ncc, ldc
      real       a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine mcrcr (nra, nca, a, lda, nrb, ncb, b, ldb,&
     &           nrc, ncc, c, ldc)
      integer    nra, nca, lda, nrb, ncb, ldb, nrc, ncc, ldc
      complex    a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine hrrrr (nra, nca, a, lda, nrb, ncb, b, ldb,&
     &           nrc, ncc, c, ldc)
      integer    nra, nca, lda, nrb, ncb, ldb, nrc, ncc, ldc
      real       a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine polrg (n, a, lda, ncoef, coef, b, ldb)
      integer    n, lda, ncoef, ldb
      real       a(lda,*), coef(*), b(ldb,*)
      end

      interface to subroutine p2lrg (n, a, lda, ncoef, coef, b, ldb,    &
     &           work)
      integer    n, lda, ncoef, ldb
      real       a(lda,*), coef(*), b(ldb,*), work(n,*)
      end

      interface to subroutine murrv (nra, nca, a, lda, nx, x, ipath, ny,&
     &           y)
      integer    nra, nca, lda, nx, ipath, ny
      real       a(lda,*), x(*), y(*)
      end

      interface to subroutine murbv (n, a, lda, nlca, nuca, nx, x,      &
     &           ipath, ny, y)
      integer    n, lda, nlca, nuca, nx, ipath, ny
      real       a(lda,n), x(nx), y(ny)
      end

      interface to subroutine mucrv (nra, nca, a, lda, nx, x, ipath, ny,&
     &           y)
      integer    nra, nca, lda, nx, ipath, ny
      complex    a(lda,*), x(*), y(*)
      end

      interface to subroutine mucbv (n, a, lda, nlca, nuca, nx, x,      &
     &           ipath, ny, y)
      integer    n, lda, nlca, nuca, nx, ipath, ny
      complex    a(lda,n), x(nx), y(ny)
      end

      interface to subroutine arbrb (n, a, lda, nlca, nuca, b, ldb,     &
     &           nlcb, nucb, c, ldc, nlcc, nucc)
      integer    n, lda, nlca, nuca, ldb, nlcb, nucb, ldc, nlcc, nucc
      real       a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine acbcb (n, a, lda, nlca, nuca, b, ldb,     &
     &           nlcb, nucb, c, ldc, nlcc, nucc)
      integer    n, lda, nlca, nuca, ldb, nlcb, nucb, ldc, nlcc, nucc
      complex    a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine nrirr (nra, nca, a, lda, anorm)
      integer    nra, nca, lda
      real       anorm, a(lda,*)
      end

      interface to subroutine nr1rr (nra, nca, a, lda, anorm)
      integer    nra, nca, lda
      real       anorm, a(lda,*)
      end

      interface to subroutine nr2rr (nra, nca, a, lda, anorm)
      integer    nra, nca, lda
      real       anorm, a(lda,*)
      end

      interface to subroutine nr1rb (n, a, lda, nlca, nuca, anorm)
      integer    n, lda, nlca, nuca
      real       anorm, a(lda,*)
      end

      interface to subroutine nr1cb (n, a, lda, nlca, nuca, anorm)
      integer    n, lda, nlca, nuca
      real       anorm
      complex    a(lda,*)
      end

      interface to real function disl2 (n, x, incx, y, incy)
      integer    n, incx, incy
      real       x(*), y(*)
      end

      interface to real function disl1 (n, x, incx, y, incy)
      integer    n, incx, incy
      real       x(*), y(*)
      end

      interface to real function disli (n, x, incx, y, incy)
      integer    n, incx, incy
      real       x(*), y(*)
      end

      interface to subroutine vconr (nx, x, ny, y, nz, z)
      integer    nx, ny, nz
      real       x(*), y(*), z(*)
      end

      interface to subroutine v2onr (nx, x, ny, y, nz, z, xwk, ywk, zwk,&
     &           wk)
      integer    nx, ny, nz
      real       x(*), y(*), z(*), wk(*)
      complex    xwk(*), ywk(*), zwk(*)
      end

      interface to subroutine vconc (nx, x, ny, y, nz, z)
      integer    nx, ny, nz
      complex    x(*), y(*), z(*)
      end

      interface to subroutine v2onc (nx, x, ny, y, nz, z, xwk, ywk, wk)
      integer    nx, ny, nz
      real       wk(*)
      complex    x(*), y(*), z(*), xwk(*), ywk(*)
      end

$IF .NOT. DEFINED (IMSL_MATH_COMMON)

      interface to subroutine dqadd (a, acc)
      double precision a, acc(2)
      end

      interface to subroutine dqini (da, dacc)
      double precision da, dacc(2)
      end

      interface to subroutine dqmul (da, db, dacc)
      double precision da, db, dacc(2)
      end

      interface to subroutine dqsto (dacc, da)
      double precision da, dacc(2)
      end

      interface to subroutine zqadd (za, zacc)
      double precision zacc(4)
      complex    *16 za
      end

      interface to subroutine zqini (za, zacc)
      double precision zacc(4)
      complex    *16 za
      end

      interface to subroutine zqmul (za, zb, zacc)
      double precision zacc(4)
      complex    *16 za, zb
      end

      interface to subroutine zqsto (zacc, za)
      double precision zacc(4)
      complex    *16 za
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine trnrr (nra, nca, a, lda, nrb, ncb, b, ldb)
      integer    nra, nca, lda, nrb, ncb, ldb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine mxtxf (nra, nca, a, lda, nb, b, ldb)
      integer    nra, nca, lda, nb, ldb
      real       a(lda,*), b(ldb,*)
      end

      interface to subroutine mxtyf (nra, nca, a, lda, nrb, ncb, b, ldb,&
     &           nrc, ncc, c, ldc)
      integer    nra, nca, lda, nrb, ncb, ldb, nrc, ncc, ldc
      real       a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to subroutine mrrrr (nra, nca, a, lda, nrb, ncb, b, ldb,&
     &           nrc, ncc, c, ldc)
      integer    nra, nca, lda, nrb, ncb, ldb, nrc, ncc, ldc
      real       a(lda,*), b(ldb,*), c(ldc,*)
      end

      interface to real function blinf (nra, nca, a, lda, x, y)
      integer    nra, nca, lda
      real       a(*), x(*), y(*)
      end

$ENDIF

!
!     Level 1 BLAS
!

$IF .NOT. DEFINED (IMSL_COMMON)

      interface to subroutine iset (n, ia, ix, incx)
      integer    n, ia, incx, ix(*)
      end

      interface to subroutine icopy (n, ix, incx, iy, incy)
      integer    n, incx, incy, ix(*), iy(*)
      end

      interface to subroutine iadd (n, ia, ix, incx)
      integer    n, ia, incx, ix(*)
      end

      interface to subroutine isub (n, ia, ix, incx)
      integer    n, ia, incx, ix(*)
      end

      interface to subroutine iswap (n, ix, incx, iy, incy)
      integer    n, incx, incy, ix(*), iy(*)
      end

      interface to double precision function dsdot (n, sx, incx, sy,    &
     &           incy)
      integer    n, incx, incy
      real       sx(*), sy(*)
      end

      interface to integer function isum (n, ix, incx)
      integer    n, incx, ix(*)
      end

      interface to integer function iimin (n, ix, incx)
      integer    n, incx, ix(*)
      end

      interface to integer function iimax (n, ix, incx)
      integer    n, incx, ix(*)
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine sset (n, sa, sx, incx)
      integer    n, incx
      real       sa, sx(*)
      end

      interface to subroutine cset (n, ca, cx, incx)
      integer    n, incx
      complex    ca, cx(*)
      end

      interface to subroutine scopy (n, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sx(*), sy(*)
      end

      interface to subroutine ccopy (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to subroutine sscal (n, sa, sx, incx)
      integer    n, incx
      real       sa, sx(*)
      end

      interface to subroutine cscal (n, ca, cx, incx)
      integer    n, incx
      complex    ca, cx(*)
      end

      interface to subroutine csscal (n, sa, cx, incx)
      integer    n, incx
      real       sa
      complex    cx(*)
      end

      interface to subroutine svcal (n, sa, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sa, sx(*), sy(*)
      end

      interface to subroutine cvcal (n, ca, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    ca, cx(*), cy(*)
      end

      interface to subroutine csvcal (n, sa, cx, incx, cy, incy)
      integer    n, incx, incy
      real       sa
      complex    cx(*), cy(*)
      end

      interface to subroutine sadd (n, sa, sx, incx)
      integer    n, incx
      real       sa, sx(*)
      end

      interface to subroutine cadd (n, ca, cx, incx)
      integer    n, incx
      complex    ca, cx(*)
      end

      interface to subroutine ssub (n, sa, sx, incx)
      integer    n, incx
      real       sa, sx(*)
      end

      interface to subroutine csub (n, ca, cx, incx)
      integer    n, incx
      complex    ca, cx(*)
      end

      interface to subroutine saxpy (n, sa, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sa, sx(*), sy(*)
      end

      interface to subroutine caxpy (n, ca, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    ca, cx(*), cy(*)
      end

      interface to subroutine sswap (n, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sx(*), sy(*)
      end

      interface to subroutine cswap (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to real function sdot (n, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sx(*), sy(*)
      end

      interface to complex function cdotu (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to complex function cdotc (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to complex function czdotc (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to complex function czdotu (n, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    cx(*), cy(*)
      end

      interface to real function sdsdot (n, sb, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sb, sx(*), sy(*)
      end

      interface to complex function czcdot (n, ca, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    ca, cx(*), cy(*)
      end

      interface to complex function czudot (n, ca, cx, incx, cy, incy)
      integer    n, incx, incy
      complex    ca, cx(*), cy(*)
      end

      interface to real function sddoti (n, sa, acc, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sa, sx(*), sy(*)
      double precision acc(2)
      end

      interface to real function sddota (n, sa, acc, sx, incx, sy, incy)
      integer    n, incx, incy
      real       sa, sx(*), sy(*)
      double precision acc(2)
      end

      interface to complex function czdoti (n, ca, acc, cx, incx, cy,   &
     &           incy)
      integer    n, incx, incy
      double precision acc(4)
      complex    ca, cx(*), cy(*)
      end

      interface to complex function czdota (n, ca, acc, cx, incx, cy,   &
     &           incy)
      integer    n, incx, incy
      double precision acc(4)
      complex    ca, cx(*), cy(*)
      end

      interface to subroutine shprod (n, sx, incx, sy, incy, sz, incz)
      integer    n, incx, incy, incz
      real       sx(*), sy(*), sz(*)
      end

      interface to real function sxyz (n, sx, incx, sy, incy, sz, incz)
      integer    n, incx, incy, incz
      real       sx(*), sy(*), sz(*)
      end

      interface to real function ssum (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to real function sasum (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to real function scasum (n, cx, incx)
      integer    n, incx
      complex    cx(*)
      end

      interface to real function snrm2 (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to real function scnrm2 (n, cx, incx)
      integer    n, incx
      complex    cx(*)
      end

      interface to real function sprdct (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to integer function ismin (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to integer function ismax (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to integer function isamin (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to integer function icamin (n, cx, incx)
      integer    n, incx
      complex    cx(*)
      end

      interface to integer function isamax (n, sx, incx)
      integer    n, incx
      real       sx(*)
      end

      interface to integer function icamax (n, cx, incx)
      integer    n, incx
      complex    cx(*)
      end

      interface to subroutine srotg (sa, sb, sc, ss)
      real       sa, sb, sc, ss
      end

      interface to subroutine srot (n, sx, incx, sy, incy, c, s)
      integer    n, incx, incy
      real       c, s, sx(*), sy(*)
      end

      interface to subroutine csrot (n, cx, incx, cy, incy, c, s)
      integer    n, incx, incy
      real       c, s
      complex    cx(*), cy(*)
      end

      interface to subroutine srotmg (sd1, sd2, sx1, sy1, sparam)
      real       sd1, sd2, sx1, sy1, sparam(5)
      end

      interface to subroutine srotm (n, sx, incx, sy, incy, sparam)
      integer    n, incx, incy
      real       sx(*), sy(*), sparam(5)
      end

      interface to subroutine csrotm (n, cx, incx, cy, incy, sparam)
      integer    n, incx, incy
      real       sparam(5)
      complex    cx(*), cy(*)
      end

$ENDIF

!
!     Level 2 BLAS
!

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine sgemv (trans, m, n, alpha, a, lda, x,     &
     &           incx, beta, y, incy)
      integer    m, n, lda, incx, incy
      real       alpha, beta, a(*), x(*), y(*)
      character  trans*1
      end

      interface to subroutine cgemv (trans, m, n, alpha, a, lda, x,     &
     &           incx, beta, y, incy)
      integer    m, n, lda, incx, incy
      complex    alpha, beta, a(*), x(*), y(*)
      character  trans*1
      end

      interface to subroutine sgbmv (trans, m, n, nlca, nuca, alpha, a, &
     &           lda, x, incx, beta, y, incy)
      integer    m, n, nlca, nuca, lda, incx, incy
      real       alpha, beta, a(lda,*), x(*), y(*)
      character  trans*1
      end

      interface to subroutine cgbmv (trans, m, n, nlca, nuca, alpha, a, &
     &           lda, x, incx, beta, y, incy)
      integer    m, n, nlca, nuca, lda, incx, incy
      complex    alpha, beta, a(lda,*), x(*), y(*)
      character  trans*1
      end

      interface to subroutine chemv (uplo, n, alpha, a, lda, x, incx,   &
     &           beta, y, incy)
      integer    n, lda, incx, incy
      complex    alpha, beta, a(lda,*), x(*), y(*)
      character  uplo*1
      end

      interface to subroutine chbmv (uplo, n, ncoda, alpha, a, lda, x,  &
     &           incx, beta, y, incy)
      integer    n, ncoda, lda, incx, incy
      complex    alpha, beta, a(lda,*), x(*), y(*)
      character  uplo*1
      end

      interface to subroutine ssymv (uplo, n, alpha, a, lda, x, incx,   &
     &           beta, y, incy)
      integer    n, lda, incx, incy
      real       alpha, beta, a(lda,*), x(*), y(*)
      character  uplo*1
      end

      interface to subroutine ssbmv (uplo, n, ncoda, alpha, a, lda, x,  &
     &           incx, beta, y, incy)
      integer    ncoda, n, lda, incx, incy
      real       alpha, beta, a(lda,*), x(*), y(*)
      character  uplo*1
      end

      interface to subroutine strmv (uplo, trans, diag, n, a, lda, x,   &
     &           incx)
      integer    n, lda, incx
      real       a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine ctrmv (uplo, trans, diag, n, a, lda, x,   &
     &           incx)
      integer    n, lda, incx
      complex    a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine stbmv (uplo, trans, diag, n, ncoda, a,    &
     &           lda, x, incx)
      integer    n, ncoda, lda, incx
      real       a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine ctbmv (uplo, trans, diag, n, ncoda, a,    &
     &           lda, x, incx)
      integer    n, ncoda, lda, incx
      complex    a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine strsv (uplo, trans, diag, n, a, lda, x,   &
     &           incx)
      integer    n, lda, incx
      real       a(*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine ctrsv (uplo, trans, diag, n, a, lda, x,   &
     &           incx)
      integer    n, lda, incx
      complex    a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine stbsv (uplo, trans, diag, n, ncoda, a,    &
     &           lda, x, incx)
      integer    n, ncoda, lda, incx
      real       a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine ctbsv (uplo, trans, diag, n, ncoda, a,    &
     &           lda, x, incx)
      integer    n, ncoda, lda, incx
      complex    a(lda,*), x(*)
      character  uplo*1, trans*1, diag*1
      end

      interface to subroutine sger (m, n, alpha, x, incx, y, incy, a,   &
     &           lda)
      integer    m, n, incx, incy, lda
      real       alpha, x(*), y(*), a(*)
      end

      interface to subroutine cgeru (m, n, alpha, x, incx, y, incy, a,  &
     &           lda)
      integer    m, n, incx, incy, lda
      complex    alpha, x(*), y(*), a(*)
      end

      interface to subroutine cgerc (m, n, alpha, x, incx, y, incy, a,  &
     &           lda)
      integer    m, n, incx, incy, lda
      complex    alpha, x(*), y(*), a(*)
      end

      interface to subroutine cher (uplo, n, alpha, x, incx, a, lda)
      integer    n, incx, lda
      real       alpha
      complex    x(*), a(*)
      character  uplo*1
      end

      interface to subroutine cher2 (uplo, n, alpha, x, incx, y, incy,  &
     &           a, lda)
      integer    n, incx, incy, lda
      complex    alpha, x(*), y(*), a(lda,*)
      character  uplo*1
      end

      interface to subroutine ssyr (uplo, n, alpha, x, incx, a, lda)
      integer    n, incx, lda
      real       alpha, x(*), a(*)
      character  uplo*1
      end

      interface to subroutine ssyr2 (uplo, n, alpha, x, incx, y, incy,  &
     &           a, lda)
      integer    n, incx, incy, lda
      real       alpha, x(*), y(*), a(lda,*)
      character  uplo*1
      end

$ENDIF

!
!     Level 3 BLAS
!

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine sgemm (transa, transb, m, n, k, alpha, a, &
     &           lda, b, ldb, beta, c, ldc)
      integer    m, n, k, lda, ldb, ldc
      real       alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  transa*1, transb*1
      end

      interface to subroutine cgemm (transa, transb, m, n, k, alpha, a, &
     &           lda, b, ldb, beta, c, ldc)
      integer    m, n, k, lda, ldb, ldc
      complex    alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  transa*1, transb*1
      end

      interface to subroutine ssymm (side, uplo, m, n, alpha, a, lda, b,&
     &           ldb, beta, c, ldc)
      integer    m, n, lda, ldb, ldc
      real       alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  side*1, uplo*1
      end

      interface to subroutine csymm (side, uplo, m, n, alpha, a, lda, b,&
     &           ldb, beta, c, ldc)
      integer    m, n, lda, ldb, ldc
      complex    alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  side*1, uplo*1
      end

      interface to subroutine chemm (side, uplo, m, n, alpha, a, lda, b,&
     &           ldb, beta, c, ldc)
      integer    m, n, lda, ldb, ldc
      complex    alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  side*1, uplo*1
      end

      interface to subroutine ssyrk (uplo, trans, n, k, alpha, a, lda,  &
     &           beta, c, ldc)
      integer    n, k, lda, ldc
      real       alpha, beta, a(lda,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine csyrk (uplo, trans, n, k, alpha, a, lda,  &
     &           beta, c, ldc)
      integer    n, k, lda, ldc
      complex    alpha, beta, a(lda,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine cherk (uplo, trans, n, k, alpha, a, lda,  &
     &           beta, c, ldc)
      integer    n, k, lda, ldc
      real       alpha, beta
      complex    a(lda,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine ssyr2k (uplo, trans, n, k, alpha, a, lda, &
     &           b, ldb, beta, c, ldc)
      integer    n, k, lda, ldb, ldc
      real       alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine csyr2k (uplo, trans, n, k, alpha, a, lda, &
     &           b, ldb, beta, c, ldc)
      integer    n, k, lda, ldb, ldc
      complex    alpha, beta, a(lda,*), b(ldb,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine cher2k (uplo, trans, n, k, alpha, a, lda, &
     &           b, ldb, beta, c, ldc)
      integer    n, k, lda, ldb, ldc
      real       beta
      complex    alpha, a(lda,*), b(ldb,*), c(ldc,*)
      character  uplo*1, trans*1
      end

      interface to subroutine strmm (side, uplo, transa, diag, m, n,    &
     &           alpha, a, lda, b, ldb)
      integer    m, n, lda, ldb
      real       alpha, a(lda,*), b(ldb,*)
      character  side*1, uplo*1, transa*1, diag*1
      end

      interface to subroutine ctrmm (side, uplo, transa, diag, m, n,    &
     &           alpha, a, lda, b, ldb)
      integer    m, n, lda, ldb
      complex    alpha, a(lda,*), b(ldb,*)
      character  side*1, uplo*1, transa*1, diag*1
      end

      interface to subroutine strsm (side, uplo, transa, diag, m, n,    &
     &           alpha, a, lda, b, ldb)
      integer    m, n, lda, ldb
      real       alpha, a(lda,*), b(ldb,*)
      character  side*1, uplo*1, transa*1, diag*1
      end

      interface to subroutine ctrsm (side, uplo, transa, diag, m, n,    &
     &           alpha, a, lda, b, ldb)
      integer    m, n, lda, ldb
      complex    alpha, a(lda,*), b(ldb,*)
      character  side*1, uplo*1, transa*1, diag*1
      end

$ENDIF

!
!     Chapter 10:  Utilities
!

      interface to subroutine wrcrn (title, nra, nca, a, lda, itring)
      integer    nra, nca, lda, itring
      complex    a(*)
      character  title*(*)
      end

      interface to subroutine wrcrl (title, nra, nca, a, lda, itring,   &
     &           fmt, rlabel, clabel)
      integer    nra, nca, lda, itring
      complex    a(*)
      character  title*(*), fmt*(*), rlabel(*)*(*), clabel(0:*)*(*)
      end

      interface to subroutine w2crl (title, nra, nca, a, lda, itring,   &
     &           fmt, rlabel, clabel, chwk)
      integer    nra, nca, lda, itring
      complex    a(*)
      character  title*(*), fmt*(*), rlabel(*)*(*), clabel(0:*)*(*),    &
     &           chwk(*)*10
      end

      interface to subroutine svrbn (n, ra, rb)
      integer    n
      real       ra(*), rb(*)
      end

      interface to subroutine svrbp (n, ra, rb, iperm)
      integer    n, iperm(*)
      real       ra(*), rb(*)
      end

      interface to real function const (name)
      character  name*(*)
      end

      interface to subroutine cunit (x, xunits, y, yunits)
      real       x, y
      character  xunits*(*), yunits*(*)
      end

      interface to real function hypot (a, b)
      real       a, b
      end

$IF .NOT. DEFINED (IMSL_MATH_COMMON)

      interface to subroutine svibn (n, ia, ib)
      integer    n, ia(*), ib(*)
      end

      interface to subroutine svibp (n, ia, ib, iperm)
      integer    n, ia(*), ib(*), iperm(*)
      end

      interface to character *(*)function verml (iselct)
      integer    iselct
      end

      interface to subroutine iumag (prodnm, ichp, iact, numopt, iopts, &
     &           ivals)
      integer    ichp, iact, numopt, iopts(*), ivals(*)
      character  prodnm*4
      end

      interface to subroutine sumag (prodnm, ichp, iact, numopt, iopts, &
     &           svals)
      integer    ichp, iact, numopt, iopts(*)
      real       svals(*)
      character  prodnm*4
      end

      interface to subroutine dumag (prodnm, ichp, iact, numopt, iopts, &
     &           dvals)
      integer    ichp, iact, numopt, iopts(*)
      double precision dvals(*)
      character  prodnm*4
      end

      interface to subroutine prime (n, npf, ipf, iexp, ipw)
      integer    n, npf, ipf(13), iexp(13), ipw(13)
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON)

      interface to subroutine wrirn (title, nrmat, ncmat, mat, ldmat,   &
     &           itring)
      integer    nrmat, ncmat, ldmat, itring, mat(ldmat,*)
      character  title*(*)
      end

      interface to subroutine wrirl (title, nrmat, ncmat, mat, ldmat,   &
     &           itring, fmt, rlabel, clabel)
      integer    nrmat, ncmat, ldmat, itring, mat(ldmat,*)
      character  title*(*), fmt*(*), rlabel(*)*(*), clabel(0:*)*(*)
      end

      interface to subroutine wropt (iopt, iset, iscope)
      integer    iopt, iset, iscope
      end

      interface to subroutine pgopt (iopt, ipage)
      integer    iopt, ipage
      end

      interface to subroutine svign (n, ia, ib)
      integer    n, ia(*), ib(*)
      end

      interface to subroutine svigp (n, ia, ib, iperm)
      integer    n, ia(*), ib(*), iperm(*)
      end

      interface to subroutine isrch (n, ivalue, ix, incx, index)
      integer    n, ivalue, incx, index, ix(*)
      end

      interface to subroutine ssrch (n, string, chx, incx, index)
      integer    n, incx, index
      character  string*(*), chx(*)*(*)
      end

      interface to character *1 function achar (i)
      integer    i
      end

      interface to integer function iachar (ch)
      character  ch
      end

      interface to integer function icase (ch)
      character  ch
      end

      interface to integer function iicsr (str1, str2)
      character  str1*(*), str2*(*)
      end

      interface to integer function iidex (chrstr, key)
      character  chrstr*(*), key*(*)
      end

      interface to subroutine cvtsi (string, number)
      integer    number
      character  string*(*)
      end

      interface to real function cpsec ()
      end

      interface to subroutine timdy (ihour, minute, isec)
      integer    ihour, minute, isec
      end

      interface to subroutine tdate (iday, month, iyear)
      integer    iday, month, iyear
      end

      interface to integer function ndays (iday, imonth, iyear)
      integer    iday, imonth, iyear
      end

      interface to subroutine ndyin (ndays, iday, month, iyear)
      integer    ndays, iday, month, iyear
      end

      interface to integer function idywk (iday, imonth, iyear)
      integer    iday, imonth, iyear
      end

      interface to subroutine rnget (iseed)
      integer    iseed
      end

      interface to subroutine rnset (iseed)
      integer    iseed
      end

      interface to subroutine rnopt (iopt)
      integer    iopt
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to subroutine wrrrn (title, nra, nca, a, lda, itring)
      integer    nra, nca, lda, itring
      real       a(*)
      character  title*(*)
      end

      interface to subroutine wrrrl (title, nra, nca, a, lda, itring,   &
     &           fmt, rlabel, clabel)
      integer    nra, nca, lda, itring
      real       a(*)
      character  title*(*), fmt*(*), rlabel(*)*(*), clabel(0:*)*(*)
      end

      interface to subroutine w2rrl (title, nra, nca, a, lda, itring,   &
     &           fmt, rlabel, clabel, chwk)
      integer    nra, nca, lda, itring
      real       a(*)
      character  title*(*), fmt*(*), rlabel(*)*(*), clabel(0:*)*(*),    &
     &           chwk(*)*10
      end

      interface to subroutine permu (n, x, ipermu, ipath, xpermu)
      integer    n, ipath, ipermu(*)
      real       x(*), xpermu(*)
      end

      interface to subroutine perma (nra, nca, a, lda, ipermu, ipath,   &
     &           aper, ldaper)
      integer    nra, nca, lda, ipath, ldaper, ipermu(*)
      real       a(lda,*), aper(ldaper,*)
      end

      interface to subroutine p2rma (nra, nca, a, lda, ipermu, ipath,   &
     &           aper, ldaper, work)
      integer    nra, nca, lda, ipath, ldaper, ipermu(*)
      real       a(lda,*), aper(ldaper,*), work(*)
      end

      interface to subroutine svrgn (n, ra, rb)
      integer    n
      real       ra(*), rb(*)
      end

      interface to subroutine svrgp (n, ra, rb, iperm)
      integer    n, iperm(*)
      real       ra(*), rb(*)
      end

      interface to subroutine srch (n, value, x, incx, index)
      integer    n, incx, index
      real       value, x(*)
      end

      interface to real function rnunf ()
      end

      interface to subroutine rnun (nr, r)
      integer    nr
      real       r(*)
      end

      interface to subroutine plotp (ndata, nfun, x, a, lda, inc, range,&
     &           symbol, xtitle, ytitle, title)
      integer    ndata, nfun, lda, inc
      real       x(*), a(lda,*), range(4)
      character  symbol*(*), xtitle*(*), ytitle*(*), title*(*)
      end

$ENDIF

!
!     Special Functions Chapter 1:  Elementary Functions
!

      interface to real function carg (z)
      complex    z
      end

      interface to real function cbrt (x)
      real       x
      end

      interface to complex function ccbrt (z)
      complex    z
      end

      interface to real function exprl (x)
      real       x
      end

      interface to complex function clog10 (z)
      complex    z
      end

      interface to real function alnrel (x)
      real       x
      end

$IF .NOT. DEFINED (IMSL_MATH_COMMON)

      interface to complex function cexprl (z)
      complex    z
      end

      interface to complex function clnrel (z)
      complex    z
      end

$ENDIF

!
!     Special Functions Chapter 2:  Trigonometric and Hyperbolic
!                                   Functions
!

      interface to complex function ctan (z)
      complex    z
      end

      interface to real function cot (x)
      real       x
      end

      interface to complex function ccot (z)
      complex    z
      end

      interface to real function sindg (x)
      real       x
      end

      interface to real function cosdg (x)
      real       x
      end

      interface to complex function casin (zinp)
      complex    zinp
      end

      interface to complex function cacos (z)
      complex    z
      end

      interface to complex function catan (z)
      complex    z
      end

      interface to complex function catan2 (csn, ccs)
      complex    csn, ccs
      end

      interface to complex function csinh (z)
      complex    z
      end

      interface to complex function ccosh (z)
      complex    z
      end

      interface to complex function ctanh (z)
      complex    z
      end

      interface to real function asinh (x)
      real       x
      end

      interface to complex function casinh (z)
      complex    z
      end

      interface to real function acosh (x)
      real       x
      end

      interface to complex function cacosh (z)
      complex    z
      end

      interface to real function atanh (x)
      real       x
      end

      interface to complex function catanh (z)
      complex    z
      end

!
!     Special Functions Chapter 3:  Exponential Integrals and Related
!                                   Functions
!

      interface to real function ei (x)
      real       x
      end

      interface to real function e1 (x)
      real       x
      end

      interface to subroutine ene (x, n, f)
      integer    n
      real       x, f(*)
      end

      interface to real function ali (x)
      real       x
      end

      interface to real function si (x)
      real       x
      end

      interface to real function ci (x)
      real       x
      end

      interface to real function cin (x)
      real       x
      end

      interface to real function shi (x)
      real       x
      end

      interface to real function chi (x)
      real       x
      end

      interface to real function cinh (x)
      real       x
      end

!
!     Special Functions Chapter 4:  Gamma Function and Related Functions
!

      interface to real function fac (n)
      integer    n
      end

      interface to real function gamr (x)
      real       x
      end

      interface to real function alngam (x)
      real       x
      end

      interface to subroutine algams (x, algm, s)
      real       x, algm, s
      end

      interface to real function gami (a, x)
      real       a, x
      end

      interface to real function gamic (a, x)
      real       a, x
      end

      interface to real function gamit (a, x)
      real       a, x
      end

      interface to real function psi (x)
      real       x
      end

      interface to real function poch (a, x)
      real       a, x
      end

      interface to real function poch1 (a, x)
      real       a, x
      end

      interface to real function albeta (a, b)
      real       a, b
      end

      interface to real function betai (x, pin, qin)
      real       x, pin, qin
      end

$IF .NOT. DEFINED (IMSL_MATH_COMMON)

      interface to complex function cgamma (z)
      complex    z
      end

      interface to complex function cgamr (z)
      complex    z
      end

      interface to complex function clngam (zin)
      complex    zin
      end

      interface to complex function cpsi (zin)
      complex    zin
      end

      interface to complex function cbeta (a, b)
      complex    a, b
      end

      interface to complex function clbeta (a, b)
      complex    a, b
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to real function binom (n, m)
      integer    n, m
      end

      interface to real function gamma (x)
      real       x
      end

      interface to subroutine r9gaml (xmin, xmax)
      real       xmin, xmax
      end

      interface to real function beta (a, b)
      real       a, b
      end

$ENDIF

!
!     Special Functions Chapter 5:  Error Function and Related Functions
!

      interface to real function erf (x)
      real       x
      end

      interface to real function erfc (x)
      real       x
      end

      interface to real function erfce (x)
      real       x
      end

      interface to complex function cerfe (z)
      complex    z
      end

      interface to real function erfi (x)
      real       x
      end

      interface to real function erfci (x)
      real       x
      end

      interface to real function daws (x)
      real       x
      end

      interface to real function fresc (x)
      real       x
      end

      interface to real function fress (x)
      real       x
      end

!
!     Special Functions Chapter 6:  Bessel Functions
!

      interface to real function bsj0 (x)
      real       x
      end

      interface to real function bsj1 (x)
      real       x
      end

      interface to real function bsy0 (x)
      real       x
      end

      interface to real function bsy1 (x)
      real       x
      end

      interface to real function bsi0 (x)
      real       x
      end

      interface to real function bsi1 (x)
      real       x
      end

      interface to real function bsk0 (x)
      real       x
      end

      interface to real function bsk1 (x)
      real       x
      end

      interface to real function bsi0e (x)
      real       x
      end

      interface to real function bsi1e (x)
      real       x
      end

      interface to real function bsk0e (x)
      real       x
      end

      interface to real function bsk1e (x)
      real       x
      end

      interface to subroutine bsjns (x, n, bs)
      integer    n
      real       x, bs(*)
      end

      interface to subroutine cbjns (z, n, cbs)
      integer    n
      complex    z, cbs(*)
      end

      interface to subroutine bsins (x, n, bsi)
      integer    n
      real       x, bsi(*)
      end

      interface to subroutine cbins (z, n, cbs)
      integer    n
      complex    z, cbs(*)
      end

      interface to subroutine bsjs (xnu, x, n, bs)
      integer    n
      real       xnu, x, bs(*)
      end

      interface to subroutine b2js (xnu, x, n, bs, wk)
      integer    n
      real       xnu, x, bs(*), wk(*)
      end

      interface to subroutine bsys (xnu, x, n, bsy)
      integer    n
      real       xnu, x, bsy(*)
      end

      interface to subroutine bsis (xnu, x, n, bsi)
      integer    n
      real       xnu, x, bsi(*)
      end

      interface to subroutine bsies (xnu, x, n, bsi)
      integer    n
      real       xnu, x, bsi(*)
      end

      interface to subroutine bsks (xnu, x, nin, bk)
      integer    nin
      real       xnu, x, bk(*)
      end

      interface to subroutine bskes (xnu, x, nin, bke)
      integer    nin
      real       xnu, x, bke(*)
      end

      interface to subroutine cbjs (xnu, z, n, cbs)
      integer    n
      real       xnu
      complex    z, cbs(*)
      end

      interface to subroutine cbys (xnu, z, n, cbs)
      integer    n
      real       xnu
      complex    z, cbs(*)
      end

      interface to subroutine c2ys (xnu, z, n, cbs, fk)
      integer    n
      real       xnu
      complex    z, cbs(*), fk(*)
      end

      interface to subroutine cbis (xnu, z, n, cbs)
      integer    n
      real       xnu
      complex    z, cbs(*)
      end

      interface to subroutine cbks (xnu, z, n, cbs)
      integer    n
      real       xnu
      complex    z, cbs(*)
      end

      interface to subroutine c2ks (xnu, z, n, cbs, fi)
      integer    n
      real       xnu
      complex    z, cbs(*), fi(*)
      end

!
!     Special Functions Chapter 7:  Kelvin Functions
!

      interface to real function ber0 (x)
      real       x
      end

      interface to real function bei0 (x)
      real       x
      end

      interface to real function aker0 (x)
      real       x
      end

      interface to real function akei0 (x)
      real       x
      end

      interface to real function berp0 (x)
      real       x
      end

      interface to real function beip0 (x)
      real       x
      end

      interface to real function akerp0 (x)
      real       x
      end

      interface to real function akeip0 (x)
      real       x
      end

      interface to real function ber1 (x)
      real       x
      end

      interface to real function bei1 (x)
      real       x
      end

      interface to real function aker1 (x)
      real       x
      end

      interface to real function akei1 (x)
      real       x
      end

!
!     Special Functions Chapter 8:  Airy Functions
!

      interface to real function ai (x)
      real       x
      end

      interface to real function bi (x)
      real       x
      end

      interface to real function aid (x)
      real       x
      end

      interface to real function bid (x)
      real       x
      end

      interface to real function aie (x)
      real       x
      end

      interface to real function bie (x)
      real       x
      end

      interface to real function aide (x)
      real       x
      end

      interface to real function bide (x)
      real       x
      end

!
!     Special Functions Chapter 9:  Elliptic Integrals
!

      interface to real function elk (x)
      real       x
      end

      interface to real function ele (x)
      real       x
      end

      interface to real function elrf (x, y, z)
      real       x, y, z
      end

      interface to real function elrd (x, y, z)
      real       x, y, z
      end

      interface to real function elrj (x, y, z, rho)
      real       x, y, z, rho
      end

      interface to real function elrc (x, y)
      real       x, y
      end

!
!     Special Functions Chapter 10:  Elliptic and Related Functions
!

      interface to complex function cwpl (z)
      complex    z
      end

      interface to complex function cwpld (z)
      complex    z
      end

      interface to complex function cwpq (z)
      complex    z
      end

      interface to complex function cwpqd (z)
      complex    z
      end

      interface to real function ejsn (x, am)
      real       x, am
      end

      interface to complex function cejsn (z, am)
      real       am
      complex    z
      end

      interface to real function ejcn (x, am)
      real       x, am
      end

      interface to complex function cejcn (z, am)
      real       am
      complex    z
      end

      interface to real function ejdn (x, am)
      real       x, am
      end

      interface to complex function cejdn (z, am)
      real       am
      complex    z
      end

!
!     Special Functions Chapter 11:  Probability Distribution Functions
!                                    and Inverses
!

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to real function bindf (k, n, p)
      integer    k, n
      real       p
      end

      interface to real function binpr (k, n, p)
      integer    k, n
      real       p
      end

      interface to real function hypdf (k, n, m, l)
      integer    k, n, m, l
      end

      interface to real function hyppr (k, n, m, l)
      integer    k, n, m, l
      end

      interface to real function poidf (k, theta)
      integer    k
      real       theta
      end

      interface to real function poipr (k, theta)
      integer    k
      real       theta
      end

      interface to real function aks1df (nobs, d)
      integer    nobs
      real       d
      end

      interface to real function ak21df (nobs, d, wk)
      integer    nobs
      real       d, wk(*)
      end

      interface to real function aks2df (nobsx, nobsy, d)
      integer    nobsx, nobsy
      real       d
      end

      interface to real function ak22df (nobsx, nobsy, d, wk)
      integer    nobsx, nobsy
      real       d, wk(*)
      end

      interface to real function anordf (x)
      real       x
      end

      interface to real function anorin (p)
      real       p
      end

      interface to real function betdf (x, pin, qin)
      real       x, pin, qin
      end

      interface to real function betin (p, pin, qin)
      real       p, pin, qin
      end

      interface to real function bnrdf (x, y, rho)
      real       x, y, rho
      end

      interface to real function chidf (chsq, df)
      real       chsq, df
      end

      interface to real function chiin (p, df)
      real       p, df
      end

      interface to real function csndf (chsq, df, alam)
      real       chsq, df, alam
      end

      interface to real function fdf (f, dfn, dfd)
      real       f, dfn, dfd
      end

      interface to real function fin (p, dfn, dfd)
      real       p, dfn, dfd
      end

      interface to real function gamdf (x, a)
      real       x, a
      end

      interface to real function tdf (t, df)
      real       t, df
      end

      interface to real function tin (p, df)
      real       p, df
      end

      interface to real function tndf (t, idf, delta)
      integer    idf
      real       t, delta
      end

      interface to real function gcdf (x0, iopt, m, x, f)
      integer    iopt, m
      real       x0, x(*), f(*)
      end

      interface to real function g4df (x0, iopt, m, x, f, wk, iwk)
      integer    iopt, m, iwk(*)
      real       x0, x(*), f(*), wk(*)
      end

      interface to real function gcin (p, iopt, m, x, f)
      integer    iopt, m
      real       p, x(*), f(*)
      end

      interface to real function g3in (p, iopt, m, x, f, wk, iwk)
      integer    iopt, m, iwk(*)
      real       p, x(*), f(*), wk(*)
      end

$ENDIF

!
!     Special Functions Chapter 12:  Mathieu Functions
!

      interface to subroutine matee (q, n, isym, iper, eval)
      integer    n, isym, iper
      real       q, eval(*)
      end

      interface to subroutine m2tee (q, n, isym, iper, eval, norder,    &
     &           workd, worke)
      integer    n, isym, iper, norder
      real       q, eval(*), workd(*), worke(*)
      end

      interface to subroutine m3tee (q, n, mmax)
      integer    n, mmax
      real       q
      end

      interface to subroutine matce (x, q, n, ce)
      integer    n
      real       x, q, ce(*)
      end

      interface to subroutine m2tce (x, q, n, ce, norder, needev, eval0,&
     &           eval1, coef, work, bsj)
      logical    needev
      integer    n, norder
      real       x, q, ce(*), eval0(*), eval1(*), coef(*), work(*),     &
     &           bsj(*)
      end

      interface to subroutine matse (x, q, n, se)
      integer    n
      real       x, q, se(*)
      end

      interface to subroutine m2tse (x, q, n, se, norder, needev, eval0,&
     &           eval1, coef, work, bsi)
      logical    needev
      integer    n, norder
      real       x, q, se(*), eval0(*), eval1(*), coef(*), work(*),     &
     &           bsi(*)
      end

!
!     Special Functions Chapter 13:  Miscellaneous Functions
!

      interface to real function spenc (x)
      real       x
      end

      interface to integer function inits (os, nos, eta)
      integer    nos
      real       eta, os(*)
      end

      interface to real function csevl (x, cs, n)
      integer    n
      real       x, cs(*)
      end

!
!     Reference Material
!

$IF .NOT. DEFINED (IMSL_COMMON)

      interface to subroutine erset (iersvr, ipact, isact)
      integer    iersvr, ipact, isact
      end

      interface to integer function iercd ()
      end

      interface to integer function n1rty (iopt)
      integer    iopt
      end

      interface to subroutine iwkcin (nelmts, nalc)
      integer    nelmts, nalc
      end

      interface to subroutine iwkin (nsu)
      integer    nsu
      end

      interface to integer function imach (n)
      integer    n
      end

      interface to subroutine umach (n, nunit)
      integer    n, nunit
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to real function amach (n)
      integer    n
      end

      interface to logical function ifnan(x)
      real       x
      end

$ENDIF

!
!     Deprecated Routines
!

      interface to subroutine e2ahf (n, neval, a, lda, small, eval,     &
     &           acopy, rwk, cwk, iwk)
      integer    n, neval, lda, iwk(*)
      real       eval(*), rwk(n,*)
      complex    a(lda,*), acopy(n,*), cwk(n,*)
      logical    small
      end

      interface to subroutine e2asf (n, neval, a, lda, small, eval,     &
     &           acopy, wk, iwk)
      integer    n, neval, lda, iwk(*)
      real       a(lda,*), eval(*), acopy(n,*), wk(*)
      logical    small
      end

      interface to subroutine e2bhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, acopy, rwk, cwk, iwk)
      integer    n, mxeval, lda, neval, iwk(*)
      real       elow, ehigh, eval(*), rwk(n,*)
      complex    a(lda,*), acopy(n,*), cwk(n,*)
      end

      interface to subroutine e2bsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval, acopy, wk, iwk)
      integer    n, mxeval, lda, ncoda, neval, iwk(*)
      real       elow, ehigh, a(lda,*), eval(*), acopy(ncoda+1,*),      &
     &           wk(n,*)
      end

      interface to subroutine e2bsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, acopy, wk, iwk)
      integer    n, mxeval, lda, neval, iwk(*)
      real       elow, ehigh, a(lda,*), eval(mxeval), acopy(n,n),       &
     &           wk(n,5)
      end

      interface to subroutine e2ccg (n, a, lda, eval, evec, ldevec,     &
     &           acopy, rwk, cwk)
      integer    n, lda, ldevec
      real       rwk(*)
      complex    a(lda,*), eval(*), evec(ldevec,*), acopy(n,*),         &
     &           cwk(n,*)
      end

      interface to subroutine e2cch (n, a, lda, eval, evec, ldevec,     &
     &           acopy, cwork)
      integer    n, lda, ldevec
      complex    a(lda,*), eval(*), evec(ldevec,*), acopy(n,*),         &
     &           cwork(n,*)
      end

      interface to subroutine e2chf (n, a, lda, eval, evec, ldevec,     &
     &           acopy, rwk, cwk)
      integer    n, lda, ldevec
      real       eval(*), rwk(*)
      complex    a(lda,*), evec(ldevec,*), acopy(n,*), cwk(*)
      end

      interface to subroutine e2crg (n, a, lda, eval, evec, ldevec,     &
     &           acopy, ecopy, rwk)
      integer    n, lda, ldevec
      real       a(lda,*), acopy(n,*), ecopy(n,*), rwk(n,*)
      complex    eval(*), evec(ldevec,*)
      end

      interface to subroutine e2crh (n, a, lda, eval, evec, ldevec,     &
     &           acopy, ecopy)
      integer    n, lda, ldevec
      real       a(lda,*), acopy(n,*), ecopy(n,*)
      complex    eval(*), evec(ldevec,*)
      end

      interface to subroutine e2csb (n, a, lda, ncoda, eval, evec,      &
     &           ldevec, acopy, wk)
      integer    n, lda, ncoda, ldevec
      real       a(lda,*), eval(*), evec(ldevec,*), acopy(ncoda+1,*),   &
     &           wk(*)
      end

      interface to subroutine e2ehf (n, nevec, a, lda, small, eval,     &
     &           evec, ldevec, acopy, rw1, rw2, cwk, iwk)
      integer    n, nevec, lda, ldevec, iwk(*)
      real       eval(*), rw1(n,*), rw2(n,*)
      complex    a(lda,*), evec(ldevec,*), acopy(n,*), cwk(n,*)
      logical    small
      end

      interface to subroutine e2esb (n, nevec, a, lda, ncoda, small,    &
     &           eval, evec, ldevec, acopy, wk, iwk)
      integer    n, nevec, lda, ncoda, ldevec, iwk(*)
      real       a(lda,*), eval(*), evec(ldevec,*), acopy(ncoda+1,*),   &
     &           wk(*)
      logical    small
      end

      interface to subroutine e2fhf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec, acopy, ecopy, rwk, cwk, iwk)
      integer    n, mxeval, lda, neval, ldevec, iwk(*)
      real       elow, ehigh, eval(*), ecopy(n,*), rwk(n,*)
      complex    a(lda,*), evec(ldevec,*), acopy(n,*), cwk(n,*)
      end

      interface to subroutine e2fsb (n, mxeval, a, lda, ncoda, elow,    &
     &           ehigh, neval, eval, evec, ldevec, acopy, wk1, wk2, iwk)
      integer    n, mxeval, lda, ncoda, neval, ldevec, iwk(*)
      real       elow, ehigh, a(lda,*), eval(*), evec(ldevec,*),        &
     &           acopy(ncoda+1,*), wk1(n,*), wk2(*)
      end

      interface to subroutine e2fsf (n, mxeval, a, lda, elow, ehigh,    &
     &           neval, eval, evec, ldevec, acopy, wk, iwk)
      integer    n, mxeval, lda, neval, ldevec, iwk(*)
      real       elow, ehigh, a(lda,*), eval(*), evec(ldevec,*),        &
     &           acopy(n,*), wk(n,*)
      end

      interface to subroutine e2lcg (n, a, lda, eval, acopy, rwk, cwk)
      integer    n, lda
      real       rwk(*)
      complex    a(lda,*), eval(*), acopy(n,*), cwk(n,*)
      end

      interface to subroutine e2lch (n, a, lda, eval, acopy)
      integer    n, lda
      complex    a(lda,*), eval(*), acopy(n,*)
      end

      interface to subroutine e2lhf (n, a, lda, eval, acopy, rwk, cwk)
      integer    n, lda
      real       eval(*), rwk(*)
      complex    a(lda,*), acopy(n,*), cwk(*)
      end

      interface to subroutine e2lrg (n, a, lda, eval, acopy, rwk)
      integer    n, lda
      real       a(lda,*), acopy(n,*), rwk(n,*)
      complex    eval(*)
      end

      interface to subroutine e2lrh (n, a, lda, eval, acopy)
      integer    n, lda
      real       a(lda,*), acopy(n,*)
      complex    eval(*)
      end

      interface to subroutine e2lsb (n, a, lda, ncoda, eval, acopy, wk)
      integer    n, lda, ncoda
      real       a(lda,*), eval(*), acopy(ncoda+1,*), wk(*)
      end

      interface to subroutine e3crg (n, low, igh, a, lda, scale)
      integer    n, low, igh, lda
      real       a(lda,*), scale(*)
      end

      interface to subroutine e3crh (n, low, igh, a, lda, eval, ecopy,  &
     &           ldecop, evec, ldevec, vector)
      integer    n, low, igh, lda, ldecop, ldevec
      real       a(lda,*), ecopy(ldecop,*)
      complex    eval(*), evec(ldevec,*)
      logical    vector
      end

      interface to subroutine e3lsf (n, a, lda, d, e, e2)
      integer    n, lda
      real       a(lda,*), d(*), e(*), e2(*)
      end

      interface to subroutine e4crg (n, low, igh, a, lda, ort, work)
      integer    n, low, igh, lda
      real       a(lda,*), ort(*), work(*)
      end

      interface to subroutine e4esf (n, nevec, a, evec, ldevec, e)
      integer    n, nevec, ldevec
      real       a(n,*), evec(ldevec,*), e(*)
      end

      interface to subroutine e5crg (n, low, igh, a, lda, ort, evec,    &
     &           ldevec, g)
      integer    n, low, igh, lda, ldevec
      real       a(lda,*), ort(*), evec(ldevec,*), g(*)
      end

      interface to subroutine e7crg (n, nevec, eval, evec, ldevec,      &
     &           vector)
      integer    n, nevec, ldevec
      complex    eval(*), evec(ldevec,*)
      logical    vector
      end

      interface to subroutine g2ccg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec, acopy, bcopy)
      integer    n, lda, ldb, ldevec
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*),                 &
     &           evec(ldevec,*), acopy(n,*), bcopy(n,*)
      end

      interface to subroutine g2crg (n, a, lda, b, ldb, alpha, beta,    &
     &           evec, ldevec, acopy, bcopy, ecopy, rwk, cwk)
      integer    n, lda, ldb, ldevec
      real       a(lda,*), b(ldb,*), beta(*), acopy(n,*), bcopy(n,*),   &
     &           ecopy(n,*), rwk(*)
      complex    alpha(*), evec(ldevec,*), cwk(*)
      end

      interface to subroutine g2lcg (n, a, lda, b, ldb, alpha, beta,    &
     &           acopy, bcopy)
      integer    n, lda, ldb
      complex    a(lda,*), b(ldb,*), alpha(*), beta(*), acopy(n,*),     &
     &           bcopy(n,*)
      end

      interface to subroutine g2lrg (n, a, lda, b, ldb, alpha, beta,    &
     &           acopy, bcopy, rwk, cwk)
      integer    n, lda, ldb
      real       a(lda,*), b(ldb,*), beta(*), acopy(n,*), bcopy(n,*),   &
     &           rwk(*)
      complex    alpha(*), cwk(*)
      end

      interface to subroutine g3ccg (n, a, b, ijob, evec, ldevec)
      integer    n, ijob, ldevec
      complex    a(n,*), b(n,*), evec(ldevec,*)
      end

      interface to subroutine g4ccg (n, a, b, evec, ldevec, ijob, alpha,&
     &           beta)
      integer    n, ldevec, ijob
      complex    a(n,*), b(n,*), evec(ldevec,*), alpha(*), beta(*)
      end

      interface to subroutine g5ccg (n, nevec, alpha, beta, evec,       &
     &           ldevec, vector, eval)
      integer    n, nevec, ldevec
      complex    alpha(*), beta(*), evec(ldevec,*), eval(*)
      logical    vector
      end

      interface to subroutine g7crg (n, nevec, alpha, beta, evec,       &
     &           ldevec, vector, eval)
      integer    n, nevec, ldevec
      real       beta(*)
      complex    alpha(*), evec(ldevec,*), eval(*)
      logical    vector
      end

      interface to subroutine ivpbs (ido, neq, fcn, x, xend, tol, param,&
     &           y)
      integer    ido, neq
      real       x, xend, tol, param(*), y(*)
      external   fcn
      end

      interface to subroutine i2pbs (ido, n, fcn, x, xend, tol, param,  &
     &           y, r, s, vnorm, wk)
      integer    ido, n
      real       x, xend, tol, param(*), y(*), r(*), s(*), wk(*)
      external   fcn, vnorm
      end

$IF .NOT. DEFINED (IMSL_MATH_COMMON)

      interface to subroutine czadd (a, acc)
      double precision acc(4)
      complex    a
      end

      interface to subroutine czini (z, acc)
      double precision acc(4)
      complex    z
      end

      interface to subroutine czmul (a, b, acc)
      double precision acc(4)
      complex    a, b
      end

      interface to subroutine czsto (acc, z)
      double precision acc(4)
      complex    z
      end

      interface to subroutine sdadd (a, acc)
      real       a
      double precision acc(2)
      end

      interface to subroutine sdini (s, acc)
      real       s
      double precision acc(2)
      end

      interface to subroutine sdmul (a, b, acc)
      real       a, b
      double precision acc(2)
      end

      interface to subroutine sdsto (acc, s)
      real       s
      double precision acc(2)
      end

$ENDIF

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)

      interface to real function g2df (x0, iopt, m, x, f, wk)
      integer    iopt, m
      real       x0, x(*), f(*), wk(*)
      end

      interface to real function g3df (xx0, iopt, m, xx, f, c)
      integer    iopt, m
      real       xx0, xx(*), f(*), c(*)
      end

      interface to real function g2in (p, iopt, m, x, f, wk)
      integer    iopt, m
      real       p, x(*), f(*), wk(*)
      end

      interface to subroutine shouap (n, sy, k, j, sa, nrh, nch, sh,    &
     &           ldh)
      integer    k, j, nch, ldh
      real       sa, sy(*), sh(ldh,*)
      end

      interface to subroutine shoutr (n, x, k, j, v, beta)
      integer    n, k, j
      real       beta, x(*), v(*)
      end

$ENDIF

$DEFINE IMSL_MATH_SINGLE	! Single-precision MATH/LIBRARY routines

$IF .NOT. DEFINED (IMSL_MATH_COMMON)
$DEFINE IMSL_MATH_COMMON	! MATH/LIBRARY routines common to both
$ENDIF				! single- and double-precision

$IF .NOT. DEFINED (IMSL_COMMON_SINGLE)
$DEFINE IMSL_COMMON_SINGLE	! Single-precision routines common to
$ENDIF				! both MATH/LIBRARY and STAT/LIBRARY

$IF .NOT. DEFINED (IMSL_COMMON)
$DEFINE IMSL_COMMON		! Routines common to both MATH/LIBRARY
$ENDIF				! and STAT/LIBRARY

$ENDIF
