axiom-source 20170501-3 / usr / share / axiom-20170501 / src / algebra / NAGF04.spad

)abbrev package NAGF04 NagLinearEquationSolvingPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:45:31 1994
++ Description:
++ This package uses the NAG Library to solve the matrix equation \br
++ \tab{5}\axiom{AX=B}, where \axiom{B}\br
++ may be a single vector or a matrix of multiple right-hand sides.
++ The matrix \axiom{A} may be real, complex, symmetric, Hermitian positive-
++ definite, or sparse. It may also be rectangular, in which case a
++ least-squares solution is obtained.

NagLinearEquationSolvingPackage() : SIG == CODE where

  S ==> Symbol
  FOP ==> FortranOutputStackPackage

  SIG ==> with

    f04adf : (Integer,Matrix Complex DoubleFloat,Integer,Integer,_
        Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result 
      ++ f04adf(ia,b,ib,n,m,ic,a,ifail)
      ++ calculates the approximate solution of a set of complex 
      ++ linear equations with multiple right-hand sides, using an LU 
      ++ factorization with partial pivoting.
      ++ See \downlink{Manual Page}{manpageXXf04adf}.

    f04arf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_
        Integer) -> Result 
      ++ f04arf(ia,b,n,a,ifail)
      ++ calculates the approximate solution of a set of real 
      ++ linear equations with a single right-hand side, using an LU 
      ++ factorization with partial pivoting.
      ++ See \downlink{Manual Page}{manpageXXf04arf}.

    f04asf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_
        Integer) -> Result 
      ++ f04asf(ia,b,n,a,ifail)
      ++ calculates the accurate solution of a set of real 
      ++ symmetric positive-definite linear equations with a single right-
      ++ hand side,  Ax=b, using a Cholesky factorization and iterative 
      ++ refinement.
      ++ See \downlink{Manual Page}{manpageXXf04asf}.

    f04atf : (Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,_
        Integer,Integer) -> Result 
      ++ f04atf(a,ia,b,n,iaa,ifail)
      ++ calculates the accurate solution of a set of real linear 
      ++ equations with a single right-hand side, using an LU 
      ++ factorization with partial pivoting, and iterative refinement.
      ++ See \downlink{Manual Page}{manpageXXf04atf}.

    f04axf : (Integer,Matrix DoubleFloat,Integer,Matrix Integer,_
        Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat) -> Result 
      ++ f04axf(n,a,licn,icn,ikeep,mtype,idisp,rhs)
      ++ calculates the approximate solution of a set of real 
      ++ sparse linear equations with a single right-hand side, Ax=b or
      ++  T                                                    
      ++ A x=b, where A has been factorized by F01BRF or F01BSF.
      ++ See \downlink{Manual Page}{manpageXXf04axf}.

    f04faf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix DoubleFloat,Integer) -> Result 
      ++ f04faf(job,n,d,e,b,ifail)
      ++ calculates the approximate solution of a set of real 
      ++ symmetric positive-definite tridiagonal linear equations.
      ++ See \downlink{Manual Page}{manpageXXf04faf}.

    f04jgf : (Integer,Integer,Integer,DoubleFloat,_
        Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result 
      ++ f04jgf(m,n,nra,tol,lwork,a,b,ifail)
      ++ finds the solution of a linear least-squares problem, Ax=b
      ++ , where A is a real m by n (m>=n) matrix and b is an m element 
      ++ vector. If the matrix of observations is not of full rank, then 
      ++ the minimal least-squares solution is returned.
      ++ See \downlink{Manual Page}{manpageXXf04jgf}.

    f04maf : (Integer,Integer,Matrix DoubleFloat,Integer,_
        Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat,_
        Matrix Integer,Matrix Integer,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix Integer,Integer) -> Result 
      ++ f04maf(n,nz,avals,licn,irn,lirn,icn,wkeep,ikeep,
      ++        inform,b,acc,noits,ifail)
      ++ e a sparse symmetric positive-definite system of linear 
      ++ equations, Ax=b, using a pre-conditioned conjugate gradient 
      ++ method, where A has been factorized by F01MAF.
      ++ See \downlink{Manual Page}{manpageXXf04maf}.

    f04mbf : (Integer,Matrix DoubleFloat,Boolean,DoubleFloat,_
        Integer,Integer,Integer,Integer,DoubleFloat,Integer,_
        Union(fn:FileName,fp:Asp28(APROD)),_
        Union(fn:FileName,fp:Asp34(MSOLVE))) -> Result 
      ++ f04mbf(n,b,precon,shift,itnlim,msglvl,lrwork,_
      ++        liwork,rtol,ifail,aprod,msolve)
      ++ solves a system of real sparse symmetric linear equations 
      ++ using a Lanczos algorithm.
      ++ See \downlink{Manual Page}{manpageXXf04mbf}.

    f04mcf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_
        Matrix Integer,Integer,Matrix DoubleFloat,Integer,Integer,_
        Integer,Integer) -> Result 
      ++ f04mcf(n,al,lal,d,nrow,ir,b,nrb,iselct,nrx,ifail)
      ++ computes the approximate solution of a system of real 
      ++ linear equations with multiple right-hand sides,  AX=B,  where A 
      ++ is a symmetric positive-definite variable-bandwidth matrix, which
      ++ has previously been factorized by F01MCF. Related systems may 
      ++ also be solved.
      ++ See \downlink{Manual Page}{manpageXXf04mcf}.

    f04qaf : (Integer,Integer,DoubleFloat,DoubleFloat,_
        DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,_
        Matrix DoubleFloat,Integer,Union(fn:FileName,_
        fp:Asp30(APROD))) -> Result 
      ++ f04qaf(m,n,damp,atol,btol,conlim,itnlim,msglvl,
      ++        lrwork,liwork,b,ifail,aprod)
      ++ solves sparse unsymmetric equations, sparse linear least-
      ++ squares problems and sparse damped linear least-squares problems,
      ++ using a Lanczos algorithm.
      ++ See \downlink{Manual Page}{manpageXXf04qaf}.

  CODE ==> add

    import Lisp
    import DoubleFloat
    import Any
    import Record
    import Integer
    import Matrix DoubleFloat
    import Boolean
    import NAGLinkSupportPackage
    import FortranPackage
    import AnyFunctions1(Integer)
    import AnyFunctions1(DoubleFloat)
    import AnyFunctions1(Boolean)
    import AnyFunctions1(Matrix Complex DoubleFloat)
    import AnyFunctions1(Matrix DoubleFloat)
    import AnyFunctions1(Matrix Integer)


    f04adf(iaArg:Integer,bArg:Matrix Complex DoubleFloat,ibArg:Integer,_
        nArg:Integer,mArg:Integer,icArg:Integer,_
        aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04adf",_
        ["ia"::S,"ib"::S,"n"::S,"m"::S,"ic"::S_
        ,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_
        ["c"::S,"wkspce"::S]$Lisp,_
        [["double"::S,["wkspce"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"m"::S_
        ,"ic"::S,"ifail"::S]$Lisp_
        ,["double complex"::S,["b"::S,"ib"::S,"m"::S]$Lisp,_
        ["c"::S,"ic"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_
        ]$Lisp,_
        ["c"::S,"a"::S,"ifail"::S]$Lisp,_
        [([iaArg::Any,ibArg::Any,nArg::Any,mArg::Any,icArg::Any,_
        ifailArg::Any,bArg::Any,aArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04arf(iaArg:Integer,bArg:Matrix DoubleFloat,nArg:Integer,_
        aArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04arf",_
        ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_
        ["c"::S,"wkspce"::S]$Lisp,_
        [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp_
        ,["a"::S,"ia"::S,"n"::S]$Lisp,["wkspce"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_
        ]$Lisp,_
        ["c"::S,"a"::S,"ifail"::S]$Lisp,_
        [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04asf(iaArg:Integer,bArg:Matrix DoubleFloat,nArg:Integer,_
        aArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04asf",_
        ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wk1"::S,"wk2"::S_
        ]$Lisp,_
        ["c"::S,"wk1"::S,"wk2"::S]$Lisp,_
        [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp,_
        ["a"::S,"ia"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,_
        ["wk2"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_
        ]$Lisp,_
        ["c"::S,"a"::S,"ifail"::S]$Lisp,_
        [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04atf(aArg:Matrix DoubleFloat,iaArg:Integer,bArg:Matrix DoubleFloat,_
        nArg:Integer,iaaArg:Integer,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04atf",_
        ["ia"::S,"n"::S,"iaa"::S,"ifail"::S,"a"::S,"b"::S,"c"::S,_
        "aa"::S,"wks1"::S,"wks2"::S]$Lisp,_
        ["c"::S,"aa"::S,"wks1"::S,"wks2"::S]$Lisp,_
        [["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_
        ,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp,_
        ["aa"::S,"iaa"::S,"n"::S]$Lisp,["wks1"::S,"n"::S]$Lisp,_
        ["wks2"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"ia"::S,"n"::S,"iaa"::S,"ifail"::S]$Lisp]$Lisp,_
        ["c"::S,"aa"::S,"ifail"::S]$Lisp,_
        [([iaArg::Any,nArg::Any,iaaArg::Any,ifailArg::Any,_
        aArg::Any,bArg::Any])@List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04axf(nArg:Integer,aArg:Matrix DoubleFloat,licnArg:Integer,_
        icnArg:Matrix Integer,ikeepArg:Matrix Integer,mtypeArg:Integer,_
        idispArg:Matrix Integer,rhsArg:Matrix DoubleFloat): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04axf",_
        ["n"::S,"licn"::S,"mtype"::S,"resid"::S,"a"::S,"icn"::S,_
        "ikeep"::S,"idisp"::S,"rhs"::S,"w"::S]$Lisp,_
        ["resid"::S,"w"::S]$Lisp,_
        [["double"::S,["a"::S,"licn"::S]$Lisp,"resid"::S_
        ,["rhs"::S,"n"::S]$Lisp,["w"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"n"::S,"licn"::S,["icn"::S,"licn"::S]$Lisp_
        ,["ikeep"::S,["*"::S,"n"::S,5$Lisp]$Lisp]$Lisp,_
        "mtype"::S,["idisp"::S,2$Lisp]$Lisp]$Lisp_
        ]$Lisp,_
        ["resid"::S,"rhs"::S]$Lisp,_
        [([nArg::Any,licnArg::Any,mtypeArg::Any,aArg::Any,icnArg::Any,_
        ikeepArg::Any,idispArg::Any,rhsArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04faf(jobArg:Integer,nArg:Integer,dArg:Matrix DoubleFloat,_
        eArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_
        ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04faf",_
        ["job"::S,"n"::S,"ifail"::S,"d"::S,"e"::S,"b"::S]$Lisp,_
        []$Lisp,_
        [["double"::S,["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_
        ,["b"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"job"::S,"n"::S,"ifail"::S]$Lisp_
        ]$Lisp,_
        ["d"::S,"e"::S,"b"::S,"ifail"::S]$Lisp,_
        [([jobArg::Any,nArg::Any,ifailArg::Any,dArg::Any,eArg::Any,bArg::Any])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04jgf(mArg:Integer,nArg:Integer,nraArg:Integer,_
        tolArg:DoubleFloat,lworkArg:Integer,aArg:Matrix DoubleFloat,_
        bArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04jgf",_
        ["m"::S,"n"::S,"nra"::S,"tol"::S,"lwork"::S_
        ,"svd"::S,"sigma"::S,"irank"::S,"ifail"::S,"work"::S,_
        "a"::S,"b"::S]$Lisp,_
        ["svd"::S,"sigma"::S,"irank"::S,"work"::S]$Lisp,_
        [["double"::S,"tol"::S,"sigma"::S,["work"::S,"lwork"::S]$Lisp_
        ,["a"::S,"nra"::S,"n"::S]$Lisp,["b"::S,"m"::S]$Lisp]$Lisp_
        ,["integer"::S,"m"::S,"n"::S,"nra"::S,"lwork"::S_
        ,"irank"::S,"ifail"::S]$Lisp_
        ,["logical"::S,"svd"::S]$Lisp_
        ]$Lisp,_
        ["svd"::S,"sigma"::S,"irank"::S,"work"::S,"a"::S,_
        "b"::S,"ifail"::S]$Lisp,_
        [([mArg::Any,nArg::Any,nraArg::Any,tolArg::Any,lworkArg::Any,_
        ifailArg::Any,aArg::Any,bArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04maf(nArg:Integer,nzArg:Integer,avalsArg:Matrix DoubleFloat,_
        licnArg:Integer,irnArg:Matrix Integer,lirnArg:Integer,_
        icnArg:Matrix Integer,wkeepArg:Matrix DoubleFloat,_
        ikeepArg:Matrix Integer,_
        informArg:Matrix Integer,bArg:Matrix DoubleFloat,_
        accArg:Matrix DoubleFloat,_
        noitsArg:Matrix Integer,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,"f04maf",_
        ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"ifail"::S_
        ,"avals"::S,"irn"::S,"icn"::S,"wkeep"::S,"ikeep"::S_
        ,"inform"::S,"work"::S,"b"::S,"acc"::S,"noits"::S]$Lisp,_
        ["work"::S]$Lisp,_
        [["double"::S,["avals"::S,"licn"::S]$Lisp,_
        ["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_
        ,["work"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp,_
        ["b"::S,"n"::S]$Lisp,["acc"::S,2$Lisp]$Lisp_
        ]$Lisp_
        ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["irn"::S,"lirn"::S]$Lisp_
        ,"lirn"::S,["icn"::S,"licn"::S]$Lisp,["ikeep"::S,_
        ["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["inform"::S,4$Lisp]$Lisp_
        ,["noits"::S,2$Lisp]$Lisp,"ifail"::S]$Lisp]$Lisp,_
        ["work"::S,"b"::S,"acc"::S,"noits"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,_
        ifailArg::Any,avalsArg::Any,irnArg::Any,icnArg::Any,wkeepArg::Any,_
        ikeepArg::Any,informArg::Any,bArg::Any,accArg::Any,noitsArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04mbf(nArg:Integer,bArg:Matrix DoubleFloat,preconArg:Boolean,_
        shiftArg:DoubleFloat,itnlimArg:Integer,msglvlArg:Integer,_
        lrworkArg:Integer,liworkArg:Integer,rtolArg:DoubleFloat,_
        ifailArg:Integer,aprodArg:Union(fn:FileName,fp:Asp28(APROD)),_
        msolveArg:Union(fn:FileName,fp:Asp34(MSOLVE))): Result == 
-- if both asps are AXIOM generated we do not need lrwork liwork
--   and will set to 1.
-- else believe the user but check that they are >0.
        if (aprodArg case fp) and (msolveArg case fp)
          then
            lrworkArg:=1
            liworkArg:=1
          else 
            lrworkArg:=max(1,lrworkArg)
            liworkArg:=max(1,liworkArg)
        pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP
        if aprodArg case fn
          then outputAsFortran(aprodArg.fn)
          else outputAsFortran(aprodArg.fp)
        popFortranOutputStack()$FOP
        pushFortranOutputStack(msolveFilename := aspFilename "msolve")$FOP
        if msolveArg case fn
          then outputAsFortran(msolveArg.fn)
          else outputAsFortran(msolveArg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([aprodFilename,msolveFilename]$Lisp,_
        "f04mbf",_
        ["n"::S,"precon"::S,"shift"::S,"itnlim"::S,"msglvl"::S_
        ,"lrwork"::S,"liwork"::S,"itn"::S,"anorm"::S,"acond"::S_
        ,"rnorm"::S,"xnorm"::S,"inform"::S,"rtol"::S,"ifail"::S_
        ,"aprod"::S,"msolve"::S,"b"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_
        ]$Lisp,["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_
        "inform"::S,"work"::S,"rwork"::S,"iwork"::S,"aprod"::S,_
        "msolve"::S]$Lisp,[["double"::S,["b"::S,"n"::S]$Lisp,"shift"::S_
        ,["x"::S,"n"::S]$Lisp,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_
         "rtol"::S,["work"::S,"n"::S,5$Lisp]$Lisp,_
        ["rwork"::S,"lrwork"::S]$Lisp_
        ,"aprod"::S,"msolve"::S]$Lisp_
        ,["integer"::S,"n"::S,"itnlim"::S,"msglvl"::S_
        ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,_
        ["iwork"::S,"liwork"::S]$Lisp]$Lisp_
        ,["logical"::S,"precon"::S]$Lisp_
        ]$Lisp,_
        ["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_
        "inform"::S,"rtol"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,preconArg::Any,shiftArg::Any,itnlimArg::Any,_
        msglvlArg::Any,lrworkArg::Any,liworkArg::Any,rtolArg::Any,_
        ifailArg::Any,bArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04mcf(nArg:Integer,alArg:Matrix DoubleFloat,lalArg:Integer,_
        dArg:Matrix DoubleFloat,nrowArg:Matrix Integer,irArg:Integer,_
        bArg:Matrix DoubleFloat,nrbArg:Integer,iselctArg:Integer,_
        nrxArg:Integer,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "f04mcf",_
        ["n"::S,"lal"::S,"ir"::S,"nrb"::S,"iselct"::S_
        ,"nrx"::S,"ifail"::S,"al"::S,"d"::S,"nrow"::S,"b"::S,"x"::S_
        ]$Lisp,_
        ["x"::S]$Lisp,_
        [["double"::S,["al"::S,"lal"::S]$Lisp,["d"::S,"n"::S]$Lisp_
        ,["b"::S,"nrb"::S,"ir"::S]$Lisp,["x"::S,"nrx"::S,"ir"::S]$Lisp]$Lisp_
        ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_
        ,"ir"::S,"nrb"::S,"iselct"::S,"nrx"::S,"ifail"::S]$Lisp_
        ]$Lisp,_
        ["x"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,lalArg::Any,irArg::Any,nrbArg::Any,iselctArg::Any,_
        nrxArg::Any,ifailArg::Any,alArg::Any,dArg::Any,nrowArg::Any,_
        bArg::Any ])@List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    f04qaf(mArg:Integer,nArg:Integer,dampArg:DoubleFloat,_
        atolArg:DoubleFloat,btolArg:DoubleFloat,conlimArg:DoubleFloat,_
        itnlimArg:Integer,msglvlArg:Integer,lrworkArg:Integer,_
        liworkArg:Integer,bArg:Matrix DoubleFloat,ifailArg:Integer,_
        aprodArg:Union(fn:FileName,fp:Asp30(APROD))): Result == 
        pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP
        if aprodArg case fn
          then outputAsFortran(aprodArg.fn)
          else outputAsFortran(aprodArg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([aprodFilename]$Lisp,_
        "f04qaf",_
        ["m"::S,"n"::S,"damp"::S,"atol"::S,"btol"::S_
        ,"conlim"::S,"itnlim"::S,"msglvl"::S,"lrwork"::S,"liwork"::S_
        ,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S_
        ,"xnorm"::S,"inform"::S,"ifail"::S,"aprod"::S,"x"::S,"se"::S,_
        "b"::S,"work"::S,"rwork"::S_
        ,"iwork"::S]$Lisp,_
        ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,_
        "arnorm"::S,"xnorm"::S,"inform"::S,"work"::S,"rwork"::S,_
        "iwork"::S,"aprod"::S]$Lisp,_
        [["double"::S,"damp"::S,"atol"::S,"btol"::S_
        ,"conlim"::S,["x"::S,"n"::S]$Lisp,["se"::S,"n"::S]$Lisp,_
        "anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S,"xnorm"::S,_
        ["b"::S,"m"::S]$Lisp_
        ,["work"::S,"n"::S,2$Lisp]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,_
        "aprod"::S]$Lisp_
        ,["integer"::S,"m"::S,"n"::S,"itnlim"::S,"msglvl"::S_
        ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,_
        ["iwork"::S,"liwork"::S]$Lisp]$Lisp]$Lisp,_
        ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,_
        "arnorm"::S,"xnorm"::S,"inform"::S,"b"::S,"ifail"::S]$Lisp,_
        [([mArg::Any,nArg::Any,dampArg::Any,atolArg::Any,btolArg::Any,_
        conlimArg::Any,itnlimArg::Any,msglvlArg::Any,lrworkArg::Any,_
        liworkArg::Any,ifailArg::Any,bArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result