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

)abbrev package NAGE04 NagOptimisationPackage
++ Author: Godfrey Nolan and Mike Dewar
++ Date Created: Jan 1994
++ Date Last Updated: Thu May 12 17:45:09 1994
++ Description:
++ This package uses the NAG Library to perform optimization.
++ An optimization problem involves minimizing a function (called
++ the objective function) of several variables, possibly subject to
++ restrictions on the values of the variables defined by a set of
++ constraint functions. The routines in the NAG Foundation Library
++ are concerned with function minimization only, since the problem
++ of maximizing a given function can be transformed into a
++ minimization problem simply by multiplying the function by -1.

NagOptimisationPackage() : SIG == CODE where

  S ==> Symbol
  FOP ==> FortranOutputStackPackage

  SIG ==> with

    e04dgf : (Integer,DoubleFloat,DoubleFloat,Integer,_
        DoubleFloat,Boolean,DoubleFloat,DoubleFloat,Integer,Integer,Integer,_
        Integer,Matrix DoubleFloat,Integer,_
        Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result 
      ++ e04dgf(n,es,fu,it,lin,list,ma,op,pr,sta,sto,ve,x,ifail,objfun)
      ++ minimizes an unconstrained nonlinear function of several 
      ++ variables using a pre-conditioned, limited memory quasi-Newton 
      ++ conjugate gradient method. First derivatives are required. The 
      ++ routine is intended for use on large scale problems.
      ++ See \downlink{Manual Page}{manpageXXe04dgf}.
      
    e04fdf : (Integer,Integer,Integer,Integer,_
        Matrix DoubleFloat,Integer,_
        Union(fn:FileName,fp:Asp50(LSFUN1))) -> Result 
      ++ e04fdf(m,n,liw,lw,x,ifail,lsfun1)
      ++ is an easy-to-use algorithm for finding an unconstrained 
      ++ minimum of a sum of squares of m nonlinear functions in n 
      ++ variables (m>=n). No derivatives are required.
      ++ See \downlink{Manual Page}{manpageXXe04fdf}.

    e04gcf : (Integer,Integer,Integer,Integer,_
        Matrix DoubleFloat,Integer,_
        Union(fn:FileName,fp:Asp19(LSFUN2))) -> Result 
      ++ e04gcf(m,n,liw,lw,x,ifail,lsfun2)
      ++ is an easy-to-use quasi-Newton algorithm for finding an 
      ++ unconstrained minimum of m nonlinear 
      ++ functions in n variables (m>=n). First derivatives are required.
      ++ See \downlink{Manual Page}{manpageXXe04gcf}.

    e04jaf : (Integer,Integer,Integer,Integer,_
        Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_
        Union(fn:FileName,fp:Asp24(FUNCT1))) -> Result 
      ++ e04jaf(n,ibound,liw,lw,bl,bu,x,ifail,funct1)
      ++ is an easy-to-use quasi-Newton algorithm for finding a 
      ++ minimum of a function F(x ,x ,...,x ), subject to fixed upper and
      ++                          1  2      n                          
      ++ lower bounds of the independent variables x ,x ,...,x , using 
      ++                                            1  2      n       
      ++ function values only.
      ++ See \downlink{Manual Page}{manpageXXe04jaf}.

    e04mbf : (Integer,Integer,Integer,Integer,_
        Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix DoubleFloat,Matrix DoubleFloat,Boolean,Integer,Integer,_
        Matrix DoubleFloat,Integer) -> Result 
      ++ e04mbf(itmax,msglvl,n,nclin,nctotl,nrowa,a,bl,bu,
      ++        cvec,linobj,liwork,lwork,x,ifail)
      ++ is an easy-to-use routine for solving linear programming 
      ++ problems, or for finding a feasible point for such problems. It 
      ++ is not intended for large sparse problems.
      ++ See \downlink{Manual Page}{manpageXXe04mbf}.

    e04naf : (Integer,Integer,Integer,Integer,Integer,Integer,Integer,_
        Integer,DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix DoubleFloat,Boolean,Boolean,Boolean,Integer,Integer,_
        Matrix DoubleFloat,Matrix Integer,Integer,_
        Union(fn:FileName,fp:Asp20(QPHESS))) -> Result 
      ++ e04naf(itmax,msglvl,n,nclin,nctotl,nrowa,nrowh,ncolh,bigbnd,a,bl,
      ++ bu,cvec,featol,hess,cold,lpp,orthog,liwork,lwork,x,istate,ifail,qphess)
      ++ is a comprehensive 
      ++ programming (QP) or linear programming (LP) problems. It is not 
      ++ intended for large sparse problems.
      ++ See \downlink{Manual Page}{manpageXXe04naf}.

    e04ucf : (Integer,Integer,Integer,Integer,Integer,Integer,_
        Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_
        Integer,Boolean,DoubleFloat,Integer,DoubleFloat,DoubleFloat,Boolean,_
        DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,Boolean,Integer,_
        Integer,Integer,Integer,Integer,DoubleFloat,DoubleFloat,DoubleFloat,_
        Integer,Integer,Integer,Integer,Integer,Matrix Integer,_
        Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_
        Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp55(CONFUN)),_
        Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result 
      ++ e04ucf(n,nclin,ncnln,nrowa,nrowj,nrowr,a,bl,bu,liwork,lwork,sta,
      ++        cra,der,fea,fun,hes,infb,infs,linf,lint,list,maji,majp,mini,
      ++        minp,mon,nonf,opt,ste,stao,stac,stoo,stoc,ve,istate,cjac,
      ++        clamda,r,x,ifail,confun,objfun)
      ++ is designed to minimize an arbitrary smooth function 
      ++ subject to constraints on the 
      ++ variables, linear constraints.  
      ++ (E04UCF  may be used for unconstrained, bound-constrained and 
      ++ linearly constrained optimization.) The user must provide 
      ++ subroutines that define the objective and constraint functions 
      ++ and as many of their first partial derivatives as possible. 
      ++ Unspecified derivatives are approximated by finite differences. 
      ++ All matrices are treated as dense, and hence E04UCF is not 
      ++ intended for large sparse problems.
      ++ See \downlink{Manual Page}{manpageXXe04ucf}.

    e04ycf : (Integer,Integer,Integer,DoubleFloat,_
        Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer) -> Result 
      ++ e04ycf(job,m,n,fsumsq,s,lv,v,ifail)
      ++ returns estimates of elements of the variance 
      ++ matrix of the estimated regression coefficients for a nonlinear 
      ++ least squares problem. The estimates are derived from the 
      ++ Jacobian of the function f(x) at the solution.
      ++ See \downlink{Manual Page}{manpageXXe04ycf}.

  CODE ==> add

    import Lisp
    import DoubleFloat
    import Any
    import Record
    import Integer
    import Matrix DoubleFloat
    import Boolean
    import NAGLinkSupportPackage
    import FortranPackage
    import Union(fn:FileName,fp:Asp49(OBJFUN))
    import AnyFunctions1(Integer)
    import AnyFunctions1(DoubleFloat)
    import AnyFunctions1(Boolean)
    import AnyFunctions1(Matrix DoubleFloat)
    import AnyFunctions1(Matrix Integer)


    e04dgf(nArg:Integer,esArg:DoubleFloat,fuArg:DoubleFloat,_
        itArg:Integer,linArg:DoubleFloat,listArg:Boolean,_
        maArg:DoubleFloat,opArg:DoubleFloat,prArg:Integer,_
        staArg:Integer,stoArg:Integer,veArg:Integer,_
        xArg:Matrix DoubleFloat,ifailArg:Integer,_
        objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == 
        pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP
        if objfunArg case fn
          then outputAsFortran(objfunArg.fn)
          else outputAsFortran(objfunArg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([objfunFilename]$Lisp,_
        "e04dgf",_
        ["n"::S,"es"::S,"fu"::S,"it"::S,"lin"::S_
        ,"list"::S,"ma"::S,"op"::S,"pr"::S,"sta"::S_
        ,"sto"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_
        ,"objfun"::S,"objgrd"::S,"x"::S,"iwork"::S,"work"::S,"iuser"::S_
        ,"user"::S]$Lisp,_
        ["iter"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,"iuser"::S,_
        "user"::S,"objfun"::S]$Lisp,_
        [["double"::S,"es"::S,"fu"::S,"lin"::S,"ma"::S_
        ,"op"::S,"objf"::S,["objgrd"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_
        ["work"::S,["*"::S,13$Lisp,"n"::S]$Lisp]$Lisp,["user"::S,"*"::S]$Lisp_
        ,"objfun"::S]$Lisp_
        ,["integer"::S,"n"::S,"it"::S,"pr"::S,"sta"::S_
        ,"sto"::S,"ve"::S,"iter"::S,"ifail"::S,["iwork"::S,_
        ["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,["iuser"::S,"*"::S]$Lisp]$Lisp_
        ,["logical"::S,"list"::S]$Lisp_
        ]$Lisp,_
        ["iter"::S,"objf"::S,"objgrd"::S,"x"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,esArg::Any,fuArg::Any,itArg::Any,linArg::Any,_
        listArg::Any,maArg::Any,opArg::Any,prArg::Any,staArg::Any,_
        stoArg::Any,veArg::Any,ifailArg::Any,xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04fdf(mArg:Integer,nArg:Integer,liwArg:Integer,_
        lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_
        lsfun1Arg:Union(fn:FileName,fp:Asp50(LSFUN1))): Result == 
        pushFortranOutputStack(lsfun1Filename := aspFilename "lsfun1")$FOP
        if lsfun1Arg case fn
          then outputAsFortran(lsfun1Arg.fn)
          else outputAsFortran(lsfun1Arg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([lsfun1Filename]$Lisp,_
        "e04fdf",_
        ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_
        ,"ifail"::S,"lsfun1"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_
        ["fsumsq"::S,"w"::S,"iw"::S,"lsfun1"::S]$Lisp,_
        [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_
        ,["x"::S,"n"::S]$Lisp,"lsfun1"::S]$Lisp_
        ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_
        ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_
        ]$Lisp,_
        ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_
        [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,_
        ifailArg::Any,xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04gcf(mArg:Integer,nArg:Integer,liwArg:Integer,_
        lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_
        lsfun2Arg:Union(fn:FileName,fp:Asp19(LSFUN2))): Result == 
        pushFortranOutputStack(lsfun2Filename := aspFilename "lsfun2")$FOP
        if lsfun2Arg case fn
                  then outputAsFortran(lsfun2Arg.fn)
                  else outputAsFortran(lsfun2Arg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([lsfun2Filename]$Lisp,_
        "e04gcf",_
        ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_
        ,"ifail"::S,"lsfun2"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_
        ["fsumsq"::S,"w"::S,"iw"::S,"lsfun2"::S]$Lisp,_
        [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_
        ,["x"::S,"n"::S]$Lisp,"lsfun2"::S]$Lisp_
        ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_
        ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp]$Lisp,_
        ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_
        [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,ifailArg::Any,_
        xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04jaf(nArg:Integer,iboundArg:Integer,liwArg:Integer,_
        lwArg:Integer,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_
        xArg:Matrix DoubleFloat,ifailArg:Integer,_
        funct1Arg:Union(fn:FileName,fp:Asp24(FUNCT1))): Result == 
        pushFortranOutputStack(funct1Filename := aspFilename "funct1")$FOP
        if funct1Arg case fn
          then outputAsFortran(funct1Arg.fn)
          else outputAsFortran(funct1Arg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([funct1Filename]$Lisp,_
        "e04jaf",_
        ["n"::S,"ibound"::S,"liw"::S,"lw"::S,"f"::S_
        ,"ifail"::S,"funct1"::S,"bl"::S,"bu"::S,"x"::S,"iw"::S,"w"::S_
        ]$Lisp,_
        ["f"::S,"iw"::S,"w"::S,"funct1"::S]$Lisp,_
        [["double"::S,"f"::S,["bl"::S,"n"::S]$Lisp_
        ,["bu"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_
        ["w"::S,"lw"::S]$Lisp,"funct1"::S]$Lisp_
        ,["integer"::S,"n"::S,"ibound"::S,"liw"::S_
        ,"lw"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_
        ]$Lisp,_
        ["f"::S,"bl"::S,"bu"::S,"x"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,iboundArg::Any,liwArg::Any,lwArg::Any,_
        ifailArg::Any,blArg::Any,buArg::Any,xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04mbf(itmaxArg:Integer,msglvlArg:Integer,nArg:Integer,_
        nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_
        aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_
        buArg:Matrix DoubleFloat,_
        cvecArg:Matrix DoubleFloat,linobjArg:Boolean,liworkArg:Integer,_
        lworkArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "e04mbf",_
        ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_
        ,"nrowa"::S,"linobj"::S,"liwork"::S,"lwork"::S,"objlp"::S_
        ,"ifail"::S,"a"::S,"bl"::S,"bu"::S,"cvec"::S,"istate"::S_
        ,"clamda"::S,"x"::S,"iwork"::S,"work"::S]$Lisp,_
        ["istate"::S,"objlp"::S,"clamda"::S,"iwork"::S,"work"::S]$Lisp,_
        [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_
        ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,_
        ["cvec"::S,"n"::S]$Lisp,"objlp"::S,["clamda"::S,"nctotl"::S]$Lisp_
        ,["x"::S,"n"::S]$Lisp,["work"::S,"lwork"::S]$Lisp]$Lisp_
        ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_
        ,"nclin"::S,"nctotl"::S,"nrowa"::S,"liwork"::S,"lwork"::S,_
        ["istate"::S,"nctotl"::S]$Lisp,"ifail"::S,_
        ["iwork"::S,"liwork"::S]$Lisp]$Lisp_
        ,["logical"::S,"linobj"::S]$Lisp]$Lisp,_
        ["istate"::S,"objlp"::S,"clamda"::S,"x"::S,"ifail"::S]$Lisp,_
        [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,_
        nctotlArg::Any,nrowaArg::Any,linobjArg::Any,liworkArg::Any,_
        lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,buArg::Any,_
        cvecArg::Any,xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04naf(itmaxArg:Integer,msglvlArg:Integer,nArg:Integer,_
        nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_
        nrowhArg:Integer,ncolhArg:Integer,bigbndArg:DoubleFloat,_
        aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_
        buArg:Matrix DoubleFloat,_
        cvecArg:Matrix DoubleFloat,featolArg:Matrix DoubleFloat,_
        hessArg:Matrix DoubleFloat,_
        coldArg:Boolean,lppArg:Boolean,orthogArg:Boolean,_
        liworkArg:Integer,lworkArg:Integer,xArg:Matrix DoubleFloat,_
        istateArg:Matrix Integer,ifailArg:Integer,_
        qphessArg:Union(fn:FileName,fp:Asp20(QPHESS))): Result == 
        pushFortranOutputStack(qphessFilename := aspFilename "qphess")$FOP
        if qphessArg case fn
          then outputAsFortran(qphessArg.fn)
          else outputAsFortran(qphessArg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([qphessFilename]$Lisp,_
        "e04naf",_
        ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_
        ,"nrowa"::S,"nrowh"::S,"ncolh"::S,"bigbnd"::S,"cold"::S_
        ,"lpp"::S,"orthog"::S,"liwork"::S,"lwork"::S,"iter"::S_
        ,"obj"::S,"ifail"::S,"qphess"::S,"a"::S,"bl"::S,"bu"::S,_
        "cvec"::S,"featol"::S_
        ,"hess"::S,"clamda"::S,"x"::S,"istate"::S,"iwork"::S_
        ,"work"::S]$Lisp,_
        ["iter"::S,"obj"::S,"clamda"::S,"iwork"::S,"work"::S,_
        "qphess"::S]$Lisp,_
        [["double"::S,"bigbnd"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_
        ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,_
        ["cvec"::S,"n"::S]$Lisp,["featol"::S,"nctotl"::S]$Lisp_
        ,["hess"::S,"nrowh"::S,"ncolh"::S]$Lisp,"obj"::S,_
        ["clamda"::S,"nctotl"::S]$Lisp,["x"::S,"n"::S]$Lisp,_
        ["work"::S,"lwork"::S]$Lisp_
        ,"qphess"::S]$Lisp_
        ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_
        ,"nclin"::S,"nctotl"::S,"nrowa"::S,"nrowh"::S,"ncolh"::S,_
        "liwork"::S,"lwork"::S,"iter"::S,["istate"::S,"nctotl"::S]$Lisp_
        ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_
        ,["logical"::S,"cold"::S,"lpp"::S,"orthog"::S]$Lisp_
        ]$Lisp,_
        ["iter"::S,"obj"::S,"clamda"::S,"x"::S,"istate"::S,"ifail"::S]$Lisp,_
        [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,_
        nctotlArg::Any,nrowaArg::Any,nrowhArg::Any,ncolhArg::Any,_
        bigbndArg::Any,coldArg::Any,lppArg::Any,orthogArg::Any,_
        liworkArg::Any,lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,_
        buArg::Any,cvecArg::Any,featolArg::Any,hessArg::Any,xArg::Any,_
        istateArg::Any ])@List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04ucf(nArg:Integer,nclinArg:Integer,ncnlnArg:Integer,_
        nrowaArg:Integer,nrowjArg:Integer,nrowrArg:Integer,_
        aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_
        buArg:Matrix DoubleFloat,_
        liworkArg:Integer,lworkArg:Integer,staArg:Boolean,_
        craArg:DoubleFloat,derArg:Integer,feaArg:DoubleFloat,_
        funArg:DoubleFloat,hesArg:Boolean,infbArg:DoubleFloat,_
        infsArg:DoubleFloat,linfArg:DoubleFloat,lintArg:DoubleFloat,_
        listArg:Boolean,majiArg:Integer,majpArg:Integer,_
        miniArg:Integer,minpArg:Integer,monArg:Integer,_
        nonfArg:DoubleFloat,optArg:DoubleFloat,steArg:DoubleFloat,_
        staoArg:Integer,stacArg:Integer,stooArg:Integer,_
        stocArg:Integer,veArg:Integer,istateArg:Matrix Integer,_
        cjacArg:Matrix DoubleFloat,clamdaArg:Matrix DoubleFloat,_
        rArg:Matrix DoubleFloat,_
        xArg:Matrix DoubleFloat,ifailArg:Integer,_
        confunArg:Union(fn:FileName,fp:Asp55(CONFUN)),_
        objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == 
        pushFortranOutputStack(confunFilename := aspFilename "confun")$FOP
        if confunArg case fn
          then outputAsFortran(confunArg.fn)
          else outputAsFortran(confunArg.fp)
        popFortranOutputStack()$FOP
        pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP
        if objfunArg case fn
          then outputAsFortran(objfunArg.fn)
          else outputAsFortran(objfunArg.fp)
        popFortranOutputStack()$FOP
        [(invokeNagman([confunFilename,objfunFilename]$Lisp,_
        "e04ucf",_
        ["n"::S,"nclin"::S,"ncnln"::S,"nrowa"::S,"nrowj"::S_
        ,"nrowr"::S,"liwork"::S,"lwork"::S,"sta"::S,"cra"::S_
        ,"der"::S,"fea"::S,"fun"::S,"hes"::S,"infb"::S_
        ,"infs"::S,"linf"::S,"lint"::S,"list"::S,"maji"::S_
        ,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"nonf"::S_
        ,"opt"::S,"ste"::S,"stao"::S,"stac"::S,"stoo"::S_
        ,"stoc"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_
        ,"confun"::S,"objfun"::S,"a"::S,"bl"::S,"bu"::S,"c"::S,"objgrd"::S_
        ,"istate"::S,"cjac"::S,"clamda"::S,"r"::S,"x"::S_
        ,"iwork"::S,"work"::S,"iuser"::S,"user"::S]$Lisp,_
        ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,_
        "iuser"::S,"user"::S,"confun"::S,"objfun"::S]$Lisp,_
        [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_
        ,["bl"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,_
        "n"::S]$Lisp]$Lisp,["bu"::S,["+"::S,["+"::S,"nclin"::S,_
        "ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_
        ,"cra"::S,"fea"::S,"fun"::S,"infb"::S,"infs"::S,"linf"::S,_
        "lint"::S,"nonf"::S,"opt"::S,"ste"::S_
        ,["c"::S,"ncnln"::S]$Lisp,"objf"::S,["objgrd"::S,"n"::S]$Lisp,_
        ["cjac"::S,"nrowj"::S,"n"::S]$Lisp,["clamda"::S,["+"::S,_
        ["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_
        ,["r"::S,"nrowr"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_
        ["work"::S,"lwork"::S]$Lisp_
        ,["user"::S,1$Lisp]$Lisp,"confun"::S,"objfun"::S]$Lisp_
        ,["integer"::S,"n"::S,"nclin"::S,"ncnln"::S_
        ,"nrowa"::S,"nrowj"::S,"nrowr"::S,"liwork"::S,"lwork"::S,"der"::S,_
        "maji"::S,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"stao"::S_
        ,"stac"::S,"stoo"::S,"stoc"::S,"ve"::S,"iter"::S,["istate"::S,_
        ["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_
        ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp,_
        ["iuser"::S,1$Lisp]$Lisp]$Lisp_
        ,["logical"::S,"sta"::S,"hes"::S,"list"::S]$Lisp_
        ]$Lisp,_
        ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"istate"::S,"cjac"::S,_
        "clamda"::S,"r"::S,"x"::S,"ifail"::S]$Lisp,_
        [([nArg::Any,nclinArg::Any,ncnlnArg::Any,nrowaArg::Any,_
        nrowjArg::Any,nrowrArg::Any,liworkArg::Any,lworkArg::Any,_
        staArg::Any,craArg::Any,derArg::Any,feaArg::Any,funArg::Any,_
        hesArg::Any,infbArg::Any,infsArg::Any,linfArg::Any,lintArg::Any,_
        listArg::Any,majiArg::Any,majpArg::Any,miniArg::Any,minpArg::Any,_
        monArg::Any,nonfArg::Any,optArg::Any,steArg::Any,staoArg::Any,_
        stacArg::Any,stooArg::Any,stocArg::Any,veArg::Any,ifailArg::Any,_
        aArg::Any,blArg::Any,buArg::Any,istateArg::Any,cjacArg::Any,_
        clamdaArg::Any,rArg::Any,xArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result

    e04ycf(jobArg:Integer,mArg:Integer,nArg:Integer,_
        fsumsqArg:DoubleFloat,sArg:Matrix DoubleFloat,lvArg:Integer,_
        vArg:Matrix DoubleFloat,ifailArg:Integer): Result == 
        [(invokeNagman(NIL$Lisp,_
        "e04ycf",_
        ["job"::S,"m"::S,"n"::S,"fsumsq"::S,"lv"::S_
        ,"ifail"::S,"s"::S,"cj"::S,"v"::S,"work"::S]$Lisp,_
        ["cj"::S,"work"::S]$Lisp,_
        [["double"::S,"fsumsq"::S,["s"::S,"n"::S]$Lisp_
        ,["cj"::S,"n"::S]$Lisp,["v"::S,"lv"::S,"n"::S]$Lisp,_
        ["work"::S,"n"::S]$Lisp]$Lisp_
        ,["integer"::S,"job"::S,"m"::S,"n"::S,"lv"::S_
        ,"ifail"::S]$Lisp_
        ]$Lisp,_
        ["cj"::S,"v"::S,"ifail"::S]$Lisp,_
        [([jobArg::Any,mArg::Any,nArg::Any,fsumsqArg::Any,lvArg::Any,_
        ifailArg::Any,sArg::Any,vArg::Any ])_
        @List Any]$Lisp)$Lisp)_
        pretend List (Record(key:Symbol,entry:Any))]$Result