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

)abbrev package OPTPACK AnnaNumericalOptimizationPackage
++ Author: Brian Dupee
++ Date Created: February 1995
++ Date Last Updated: December 1997
++ Description:
++ \axiomType{AnnaNumericalOptimizationPackage} is a \axiom{package} of 
++ functions for the \axiomType{NumericalOptimizationCategory} 
++ with \axiom{measure} and \axiom{optimize}.

AnnaNumericalOptimizationPackage() : SIG == CODE where

 EDF  ==> Expression DoubleFloat
 LEDF  ==> List Expression DoubleFloat
 LDF  ==> List DoubleFloat
 MDF  ==> Matrix DoubleFloat
 DF  ==> DoubleFloat
 LOCDF  ==> List OrderedCompletion DoubleFloat
 OCDF  ==> OrderedCompletion DoubleFloat
 LOCF  ==> List OrderedCompletion Float
 OCF  ==> OrderedCompletion Float
 LEF  ==> List Expression Float
 EF  ==> Expression Float
 LF  ==> List Float
 F  ==> Float
 LS  ==> List Symbol
 LST  ==> List String
 INT  ==> Integer
 NOA  ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF)
 LSA  ==> Record(lfn:LEDF, init:LDF)
 IFL  ==> List(Record(ifail:Integer,instruction:String))
 Entry  ==> Record(chapter:String, type:String, domainName: String, 
                     defaultMin:F, measure:F, failList:IFL, explList:LST)
 Measure  ==> Record(measure:F,name:String, explanations:List String)
 Measure2  ==> Record(measure:F,explanations:String)
 RT  ==> RoutinesTable
 UNOALSA  ==> Union(noa:NOA,lsa:LSA)

 SIG ==> with

  measure : NumericalOptimizationProblem -> Measure
    ++ measure(prob) is a top level ANNA function for identifying the most
    ++ appropriate numerical routine from those in the routines table
    ++ provided for solving the numerical optimization problem defined by 
    ++ \axiom{prob} by checking various attributes of the functions and 
    ++ calculating a measure of compatibility of each routine to these 
    ++ attributes.
    ++
    ++ It calls each \axiom{domain} of \axiom{category}
    ++ \axiomType{NumericalOptimizationCategory} in turn to calculate all 
    ++ measures and returns the best the name of the most 
    ++ appropriate domain and any other relevant information.

  measure : (NumericalOptimizationProblem,RT) -> Measure
    ++ measure(prob,R) is a top level ANNA function for identifying the most
    ++ appropriate numerical routine from those in the routines table
    ++ provided for solving the numerical optimization problem defined by 
    ++ \axiom{prob} by checking various attributes of the functions and 
    ++ calculating a measure of compatibility of each routine to these 
    ++ attributes.
    ++
    ++ It calls each \axiom{domain} listed in \axiom{R} of \axiom{category}
    ++ \axiomType{NumericalOptimizationCategory} in turn to calculate all 
    ++ measures and returns the best the name of the most 
    ++ appropriate domain and any other relevant information.

  optimize : (NumericalOptimizationProblem,RT) -> Result
    ++ optimize(prob,routines) is a top level ANNA function to 
    ++ minimize a function or a set of functions with any constraints
    ++ as defined within \axiom{prob}.
    ++
    ++ It iterates over the \axiom{domains} listed in \axiom{routines} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  optimize : NumericalOptimizationProblem -> Result
    ++ optimize(prob) is a top level ANNA function to 
    ++ minimize a function or a set of functions with any constraints
    ++ as defined within \axiom{prob}.
    ++
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  goodnessOfFit : NumericalOptimizationProblem -> Result
    ++ goodnessOfFit(prob) is a top level ANNA function to 
    ++ check to goodness of fit of a least squares model 
    ++ as defined within \axiom{prob}.
    ++
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.
    ++ It then calls the numerical routine \axiomType{E04YCF} to get estimates
    ++ of the variance-covariance matrix of the regression coefficients of 
    ++ the least-squares problem.
    ++ 
    ++ It thus returns both the results of the optimization and the
    ++ variance-covariance calculation.

  optimize : (EF,LF,LOCF,LEF,LOCF) -> Result 
    ++ optimize(f,start,lower,cons,upper) is a top level ANNA function to 
    ++ minimize a function, \axiom{f}, of one or more variables with the 
    ++ given constraints.
    ++
    ++ These constraints may be simple constraints on the variables
    ++ in which case \axiom{cons} would be an empty list and the bounds on
    ++ those variables defined in \axiom{lower} and \axiom{upper}, or a 
    ++ mixture of simple, linear and non-linear constraints, where
    ++ \axiom{cons} contains the linear and non-linear constraints and
    ++ the bounds on these are added to \axiom{upper} and \axiom{lower}.
    ++
    ++ The parameter \axiom{start} is a list of the initial guesses of the
    ++ values of the variables.
    ++ 
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  optimize : (EF,LF,LOCF,LOCF) -> Result 
    ++ optimize(f,start,lower,upper) is a top level ANNA function to 
    ++ minimize a function, \axiom{f}, of one or more variables with 
    ++ simple constraints.  The bounds on
    ++ the variables are defined in \axiom{lower} and \axiom{upper}.
    ++
    ++ The parameter \axiom{start} is a list of the initial guesses of the
    ++ values of the variables.
    ++ 
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  optimize : (EF,LF) -> Result 
    ++ optimize(f,start) is a top level ANNA function to 
    ++ minimize a function, \axiom{f}, of one or more variables without
    ++ constraints. 
    ++
    ++ The parameter \axiom{start} is a list of the initial guesses of the
    ++ values of the variables.
    ++ 
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  optimize : (LEF,LF) -> Result 
    ++ optimize(lf,start) is a top level ANNA function to 
    ++ minimize a set of functions, \axiom{lf}, of one or more variables 
    ++ without constraints a least-squares problem. 
    ++
    ++ The parameter \axiom{start} is a list of the initial guesses of the
    ++ values of the variables.
    ++ 
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.

  goodnessOfFit : (LEF,LF) -> Result 
    ++ goodnessOfFit(lf,start) is a top level ANNA function to 
    ++ check to goodness of fit of a least squares model the minimization
    ++ of a set of functions, \axiom{lf}, of one or more variables without 
    ++ constraints.
    ++
    ++ The parameter \axiom{start} is a list of the initial guesses of the
    ++ values of the variables.
    ++ 
    ++ It iterates over the \axiom{domains} of 
    ++ \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.
    ++ It then calls the numerical routine \axiomType{E04YCF} to get estimates
    ++ of the variance-covariance matrix of the regression coefficients of 
    ++ the least-squares problem.
    ++ 
    ++ It thus returns both the results of the optimization and the
    ++ variance-covariance calculation.
    ++
    ++ goodnessOfFit(lf,start) is a top level function to iterate over 
    ++ the \axiom{domains} of \axiomType{NumericalOptimizationCategory} 
    ++ to get the name and other relevant information of the best
    ++ \axiom{measure} and then optimize the function on that \axiom{domain}.
    ++ It then checks the goodness of fit of the least squares model.

 CODE ==> add

  preAnalysis:RT -> RT
  zeroMeasure:Measure -> Result
  optimizeSpecific:(UNOALSA,String) -> Result
  measureSpecific:(String,RT,UNOALSA) -> Measure2
  changeName:(Result,String) -> Result
  recoverAfterFail:(UNOALSA,RT,Measure,INT,Result) -> _
    Record(a:Result,b:Measure)
  constant:UNOALSA -> Union(DF, "failed")
  optimizeConstant:DF -> Result

  import ExpertSystemToolsPackage,e04AgentsPackage,NumericalOptimizationProblem

  constant(args:UNOALSA):Union(DF,"failed") ==
    args case noa =>
      Args := args.noa
      f := Args.fn
      retractIfCan(f)@Union(DoubleFloat,"failed")
    "failed"

  optimizeConstant(c:DF): Result ==
    a := coerce(c)$AnyFunctions1(DF)
    text := coerce("Constant Function")$AnyFunctions1(String)
    construct([[objf@Symbol,a],[method@Symbol,text]])$Result

  preAnalysis(args:UNOALSA,t:RT):RT == 
    r := selectOptimizationRoutines(t)$RT
    args case lsa =>
      selectSumOfSquaresRoutines(r)$RT
    r

  zeroMeasure(m:Measure):Result ==
    a := coerce(0$F)$AnyFunctions1(F)
    text := coerce("Zero Measure")$AnyFunctions1(String)
    r := construct([[objf@Symbol,a],[method@Symbol,text]])$Result
    concat(measure2Result m,r)

  measureSpecific(name:String,R:RT,args:UNOALSA): Measure2 ==
    args case noa =>
      arg:NOA := args.noa
      name = "e04dgfAnnaType" => measure(R,arg)$e04dgfAnnaType
      name = "e04fdfAnnaType" => measure(R,arg)$e04fdfAnnaType
      name = "e04gcfAnnaType" => measure(R,arg)$e04gcfAnnaType
      name = "e04jafAnnaType" => measure(R,arg)$e04jafAnnaType
      name = "e04mbfAnnaType" => measure(R,arg)$e04mbfAnnaType
      name = "e04nafAnnaType" => measure(R,arg)$e04nafAnnaType
      name = "e04ucfAnnaType" => measure(R,arg)$e04ucfAnnaType
      error("measureSpecific","invalid type name: " name)$ErrorFunctions
    args case lsa =>
      arg2:LSA := args.lsa
      name = "e04fdfAnnaType" => measure(R,arg2)$e04fdfAnnaType
      name = "e04gcfAnnaType" => measure(R,arg2)$e04gcfAnnaType
      error("measureSpecific","invalid type name: " name)$ErrorFunctions
    error("measureSpecific","invalid argument type")$ErrorFunctions

  measure(Args:NumericalOptimizationProblem,R:RT):Measure ==
    args:UNOALSA := retract(Args)$NumericalOptimizationProblem
    sofar := 0$F
    best := "none" :: String
    routs := copy R
    routs := preAnalysis(args,routs)
    empty?(routs)$RT => 
      error("measure", "no routines found")$ErrorFunctions
    rout := inspect(routs)$RT
    e := retract(rout.entry)$AnyFunctions1(Entry)
    meth := empty()$(List String)
    for i in 1..# routs repeat
      rout := extract!(routs)$RT
      e := retract(rout.entry)$AnyFunctions1(Entry)
      n := e.domainName
      if e.defaultMin > sofar then
        m := measureSpecific(n,R,args)
        if m.measure > sofar then
          sofar := m.measure
          best := n
        str := [concat(concat([string(rout.key)$Symbol,"measure: ",
                 outputMeasure(m.measure)," - "],
                   m.explanations)$(List String))$String]
      else 
        str := [concat([string(rout.key)$Symbol
                         ," is no better than other routines"])$String]
      meth := append(meth,str)$(List String)
    [sofar,best,meth]

  measure(args:NumericalOptimizationProblem):Measure ==
    measure(args,routines()$RT)

  optimizeSpecific(args:UNOALSA,name:String):Result ==
    args case noa =>
      arg:NOA := args.noa
      name = "e04dgfAnnaType" => numericalOptimization(arg)$e04dgfAnnaType
      name = "e04fdfAnnaType" => numericalOptimization(arg)$e04fdfAnnaType
      name = "e04gcfAnnaType" => numericalOptimization(arg)$e04gcfAnnaType
      name = "e04jafAnnaType" => numericalOptimization(arg)$e04jafAnnaType
      name = "e04mbfAnnaType" => numericalOptimization(arg)$e04mbfAnnaType
      name = "e04nafAnnaType" => numericalOptimization(arg)$e04nafAnnaType
      name = "e04ucfAnnaType" => numericalOptimization(arg)$e04ucfAnnaType
      error("optimizeSpecific","invalid type name: " name)$ErrorFunctions
    args case lsa =>
      arg2:LSA := args.lsa
      name = "e04fdfAnnaType" => numericalOptimization(arg2)$e04fdfAnnaType
      name = "e04gcfAnnaType" => numericalOptimization(arg2)$e04gcfAnnaType
      error("optimizeSpecific","invalid type name: " name)$ErrorFunctions
    error("optimizeSpecific","invalid type name: " name)$ErrorFunctions

  changeName(ans:Result,name:String):Result ==
    st:String := concat([name,"Answer"])$String
    sy:Symbol := coerce(st)$Symbol
    anyAns:Any := coerce(ans)$AnyFunctions1(Result)
    construct([[sy,anyAns]])$Result

  recoverAfterFail(args:UNOALSA,routs:RT,m:Measure,
                     iint:INT,r:Result):Record(a:Result,b:Measure) ==
    while positive?(iint) repeat
      routineName := m.name
      s := recoverAfterFail(routs,routineName(1..6),iint)$RT
      s case "failed" => iint := 0
      (s = "no action")@Boolean => iint := 0
      fl := coerce(s)$AnyFunctions1(String)
      flrec:Record(key:Symbol,entry:Any):=[failure@Symbol,fl]
      m2 := measure(args::NumericalOptimizationProblem,routs)
      zero?(m2.measure) => iint := 0
      r2:Result := optimizeSpecific(args,m2.name)
      m := m2
      insert!(flrec,r2)$Result
      r := concat(r2,changeName(r,routineName))
      iany := search(ifail@Symbol,r2)$Result
      iany case "failed" => iint := 0
      iint := retract(iany)$AnyFunctions1(INT)
    [r,m]

  optimize(Args:NumericalOptimizationProblem,t:RT):Result ==
    args:UNOALSA := retract(Args)$NumericalOptimizationProblem
    routs := copy(t)$RT
    c:Union(DF,"failed") := constant(args)
    c case DF => optimizeConstant(c)
    m := measure(Args,routs)
    zero?(m.measure) => zeroMeasure m
    r := optimizeSpecific(args,n := m.name)
    iany := search(ifail@Symbol,r)$Result
    iint := 0$INT
    if (iany case Any) then
      iint := retract(iany)$AnyFunctions1(INT)
    if positive?(iint) then
      tu:Record(a:Result,b:Measure) := recoverAfterFail(args,routs,m,iint,r)
      r := tu.a
      m := tu.b
    r := concat(measure2Result m,r)
    expl := getExplanations(routs,n(1..6))$RoutinesTable
    expla := coerce(expl)$AnyFunctions1(LST)
    explaa:Record(key:Symbol,entry:Any) := ["explanations"::Symbol,expla]
    r := concat(construct([explaa]),r)
    att:List String := optAttributes(args)
    atta := coerce(att)$AnyFunctions1(List String)
    attr:Record(key:Symbol,entry:Any) := [attributes@Symbol,atta]
    insert!(attr,r)$Result

  optimize(args:NumericalOptimizationProblem):Result ==
    optimize(args,routines()$RT)

  goodnessOfFit(Args:NumericalOptimizationProblem):Result ==
    r := optimize(Args)
    args1:UNOALSA := retract(Args)$NumericalOptimizationProblem
    args1 case noa => error("goodnessOfFit","Not an appropriate problem")
    args:LSA := args1.lsa
    lf := args.lfn
    n:INT := #(variables(args))
    m:INT := # lf
    me := search(method,r)$Result
    me case "failed" => r
    meth := retract(me)$AnyFunctions1(Result)
    na := search(nameOfRoutine,meth)$Result
    na case "failed" => r
    name := retract(na)$AnyFunctions1(String)
    temp:INT := (n*(n-1)) quo 2
    ns:INT :=
      name = "e04fdfAnnaType" => 6*n+(2+n)*m+1+max(1,temp)
      8*n+(n+2)*m+temp+1+max(1,temp)
    nv:INT := ns+n
    ww := search(w,r)$Result
    ww case "failed" => r
    ws:MDF := retract(ww)$AnyFunctions1(MDF)
    fr := search(objf,r)$Result
    fr case "failed" => r
    f := retract(fr)$AnyFunctions1(DF)
    s := subMatrix(ws,1,1,ns,nv-1)$MDF
    v := subMatrix(ws,1,1,nv,nv+n*n-1)$MDF
    r2 := e04ycf(0,m,n,f,s,n,v,-1)$NagOptimisationPackage
    concat(r,r2)

  optimize(f:EF,start:LF,lower:LOCF,cons:LEF,upper:LOCF):Result ==
    args:NOA := [ef2edf(f),[f2df i for i in start],[ocf2ocdf j for j in lower],
                 [ef2edf k for k in cons], [ocf2ocdf l for l in upper]]
    optimize(args::NumericalOptimizationProblem)

  optimize(f:EF,start:LF,lower:LOCF,upper:LOCF):Result ==
    optimize(f,start,lower,empty()$LEF,upper)

  optimize(f:EF,start:LF):Result ==
    optimize(f,start,empty()$LOCF,empty()$LOCF)

  optimize(lf:LEF,start:LF):Result ==
    args:LSA := [[ef2edf i for i in lf],[f2df j for j in start]]
    optimize(args::NumericalOptimizationProblem)

  goodnessOfFit(lf:LEF,start:LF):Result ==
    args:LSA := [[ef2edf i for i in lf],[f2df j for j in start]]
    goodnessOfFit(args::NumericalOptimizationProblem)