diff options
author | dos-reis <gdr@axiomatics.org> | 2007-08-14 05:14:52 +0000 |
---|---|---|
committer | dos-reis <gdr@axiomatics.org> | 2007-08-14 05:14:52 +0000 |
commit | ab8cc85adde879fb963c94d15675783f2cf4b183 (patch) | |
tree | c202482327f474583b750b2c45dedfc4e4312b1d /src/algebra/e04.spad.pamphlet | |
download | open-axiom-ab8cc85adde879fb963c94d15675783f2cf4b183.tar.gz |
Initial population.
Diffstat (limited to 'src/algebra/e04.spad.pamphlet')
-rw-r--r-- | src/algebra/e04.spad.pamphlet | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/src/algebra/e04.spad.pamphlet b/src/algebra/e04.spad.pamphlet new file mode 100644 index 00000000..e0f482f8 --- /dev/null +++ b/src/algebra/e04.spad.pamphlet @@ -0,0 +1,397 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra e04.spad} +\author{Godfrey Nolan, Mike Dewar} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{package NAGE04 NagOptimisationPackage} +<<package NAGE04 NagOptimisationPackage>>= +)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. +++See \downlink{Manual Page}{manpageXXe04}. +NagOptimisationPackage(): Exports == Implementation where + S ==> Symbol + FOP ==> FortranOutputStackPackage + + Exports ==> 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}. + Implementation ==> 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 + +@ +\section{License} +<<license>>= +--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. +--All rights reserved. +-- +--Redistribution and use in source and binary forms, with or without +--modification, are permitted provided that the following conditions are +--met: +-- +-- - Redistributions of source code must retain the above copyright +-- notice, this list of conditions and the following disclaimer. +-- +-- - Redistributions in binary form must reproduce the above copyright +-- notice, this list of conditions and the following disclaimer in +-- the documentation and/or other materials provided with the +-- distribution. +-- +-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the +-- names of its contributors may be used to endorse or promote products +-- derived from this software without specific prior written permission. +-- +--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@ +<<*>>= +<<license>> + +<<package NAGE04 NagOptimisationPackage>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} |