Changeset 1021

Timestamp:

06/15/08 06:35:08 (4 years ago)

Author:

dmitrey.kroshko

Message:

major changes for ralg, some updates in docstrings, some changes, implementation of prob.point

Location:

trunk/openopt/scikits/openopt

Files:

• Kernel/BaseProblem.py (modified) (2 diffs)
• Kernel/Point.py (added)
• Kernel/runProbSolver.py (modified) (8 diffs)
• __init__.py (modified) (2 diffs)
• solvers/CoinOr/ipopt_oo.py (modified) (1 diff)
• solvers/UkrOpt/ralg_oo.py (modified) (7 diffs)

trunk/openopt/scikits/openopt/Kernel/BaseProblem.py

@@ -7 +7 @@
 from Residuals import Residuals
 from ooIter import ooIter
+from Point import Point
 from ooCheckGradient import ooCheckGradient
 from ooIterPrint import ooTextOutput
+
 ProbDefaults = {'diffInt': 1e-7,  'xtol': 1e-6,  'noise': 0}
 
@@ -77 +79 @@
 
         self.F = lambda x: self.objFuncMultiple2Single(self.objFunc(x)) # TODO: should be changes for LP, MILP, QP classes!
+
+        self.point = lambda *args,  **kwargs: Point(self, *args,  **kwargs)
 
         #you can redirect these ones

trunk/openopt/scikits/openopt/Kernel/runProbSolver.py

@@ -10 +10 @@
 from BaseProblem import ProbDefaults
 from scikits.openopt.Kernel.ooMisc import __solverPaths__
-ConTolMultiplier = 0.9999
+ConTolMultiplier = 0.8
 
 if __solverPaths__ is None:
@@ -23 +23 @@
                 __solverPaths__[file[:-6]] = 'scikits.openopt.solvers.' + string.join(rd,'.') + '.'+file[:-3]
 
-
-def my_import(name):
-    mod = __import__(name)
-    components = name.split('.')
-    for comp in components[1:]:
-        mod = getattr(mod, comp)
-    return mod
-
-class EmptyClass: pass
-class OpenOptResult: pass
 
 def runProbSolver(p_, solver_str, *args, **kwargs):
@@ -128 +118 @@
 
 
-    p.stopdict = dict()
+    p.stopdict = {}
 
     for s in ('f', 'df', 'd2f', 'c', 'dc', 'd2c', 'h', 'dh', 'd2h', 'l', 'dl', 'd2l'):
@@ -136 +126 @@
                 p.nEvals[s] = 0
                 A = getattr(p,s)
+
                 if callable(A): #TODO: add or ndarray(A)!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                     A = (A,)#make tuple
@@ -205 +196 @@
         if not hasattr(p,  'fk'): p.fk = p.f(p.xk)
 
-    if p.invertObjFunc: p.fk, p.ff = -p.fk, -p.ff
+    if p.invertObjFunc:  p.fk, p.ff = -p.fk, -p.ff
+
     p.ff = p.objFuncMultiple2Single(p.ff)
     #if not hasattr(p, 'xf'): p.xf = p.xk
@@ -215 +207 @@
     p.stopcase = stopcase(p)
 
-
-
-
-
-##    #for more safety
-##    p.ff = p.f(p.xf)
-
     if p.invertObjFunc: p.iterfcn(p.xf, -p.ff)
     else: p.iterfcn(p.xf, p.ff)
@@ -267 +252 @@
     r.evals = p.nEvals
     r.evals['iter'] = p.iter
+
+    p.invertObjFunc = False
 
     if p.iprint < 0:
@@ -293 +280 @@
 
 
+##################################################################
+def my_import(name):
+    mod = __import__(name)
+    components = name.split('.')
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
+class EmptyClass: pass
+class OpenOptResult: pass

trunk/openopt/scikits/openopt/__init__.py

@@ -3 +3 @@
 
 #from info import __doc__, __version__
-
 
 from oo import LP, NLP, NSP, MILP, QP, NLSP, LSP, GLP, LLSP,  MMP
@@ -12 +11 @@
 test = NumpyTest().test
 
-    
+

trunk/openopt/scikits/openopt/solvers/CoinOr/ipopt_oo.py

@@ -9 +9 @@
     __name__ = 'ipopt'
     __license__ = "CPL"
-    #__authors__ = ''
-    #__alg__ = ""
+    __authors__ = 'Carl Laird (Carnegie Mellon University) and Andreas Wachter'
+    __alg__ = "A. Wachter and L. T. Biegler, On the Implementation of a Primal-Dual Interior Point Filter Line Search Algorithm for Large-Scale Nonlinear Programming, Mathematical Programming 106(1), pp. 25-57, 2006 "
     __homepage__ = 'http://www.coin-or.org/'
-    #__info__ = ""
+    __info__ = "requires pyipopt made by Eric Xu You"
     __constraintsThatCannotBeHandled__ = [] # empty list means the solver can handle all constraints
 

trunk/openopt/scikits/openopt/solvers/UkrOpt/ralg_oo.py

@@ -2 +2 @@
 from numpy.linalg import norm
 from scikits.openopt.Kernel.BaseAlg import *
+from scikits.openopt.Kernel.Point import Point
 from scikits.openopt.Kernel.setDefaultIterFuncs import SMALL_DELTA_X,  SMALL_DELTA_F,  SMALL_DF,  IS_LINE_SEARCH_FAILED
 from UkrOptMisc import getConstrDirection
@@ -17 +18 @@
     hmult = 0.5
     T = float64
-    needRej = lambda self, p, b, g: norm(b.flatten(), 1)  < min(1e-10, 1e-5*p.gradtol)
+    needRej = lambda self, p, b, g_dilated, g: norm(g_dilated)  < 1e-10*norm(g)
     #checkTurnByGradient = True
 
@@ -98 +99 @@
                     ls1 = 0
 
-                f = p.f(x)
-                mr = p.getMaxResidual(x)
-
-                if ls == 0: fprev, mrprev,  xprev = p.fk,  p.rk,  p.xk.copy()
+                newPoint = p.point(x)
+
+                if ls == 0:
+                    oldPoint = p.point(p.xk, f = p.fk, mr = p.rk)
 
                 #if not self.checkTurnByGradient:
-                if p.__1stBetterThan2nd__(fprev,  f,  mrprev,  mr):
-                    if p.noise==0 or p.__1stCertainlyBetterThan2ndTakingIntoAcoountNoise__(fprev,  f,  mrprev,  mr):
-                        pass# and go to label "Line Search Finished"
-                    else: continue
-                else:
-                    if fprev ==  f and   mrprev ==  mr: pass # and go to label "Line Search Finished"
-                    elif ls>10:
-                        if fprev >=  f  and max(mrprev, p.contol) >=  mr:continue
+                if newPoint.betterThan(oldPoint):
+                    #TODO: handle possible noise here
+                    if ls>10:
+                        if oldPoint.f() >=  newPoint.f()  and max(oldPoint.mr(), p.contol) >=  newPoint.mr():
+                            oldPoint, newPoint = newPoint,  None
+                            continue
                         else:
                             doDilation = False
                             # and go to label "Line Search Finished"
                     else:
-                        fprev, mrprev,  xprev = f,  mr,  x.copy()
+                        oldPoint, newPoint = newPoint,  None
                         continue
 
                 #Label "Line Search Finished"
-                g2 = self.__getRalgDirection__(x, p)
-                fk,  xk,  rk = f,  x.copy(),  mr
                 break
 
+            iterPoint = newPoint
+            x = iterPoint.x
+
+            doBackwardSearch = 1
             if ls == p.maxLineSearch:
                 p.istop,  p.msg = IS_LINE_SEARCH_FAILED,  'maxLineSearch (' + str(p.maxLineSearch) + ') has been exceeded'
                 return
             elif ls == 0 and doBackwardSearch:
-               if p.__1stBetterThan2nd__(p.fk,  f,  p.rk,  rk):
-                    x_no_backward = x.copy()
-                    f_no_backward = p.f(x_no_backward)
-                    mr_no_backward = p.getMaxResidual(x_no_backward)
+                if oldPoint.betterThan(newPoint):
+                    PrevPoint = iterPoint
                     while 1:
                         hs *= self.hmult
-
-                        x_prev, hs_prev, g2_prev = x.copy(), hs, g2.copy()
-                        f_prev = p.f(x_prev)
-                        mr_prev = max(p.getMaxResidual(x), p.contol)
+                        hs_prev = hs
 
                         if itn == 0:
@@ -145 +141 @@
                             hs /= self.hmult
 
-                        mr_new = p.getMaxResidual(x)
-                        f_new = p.f(x)
-
-#                        if p.__1stBetterThan2nd__(f_new,  f_prev,  mr_new,  mr_prev):
-#                            bestIterPoint,  bestIterPointF,  bestIterPointDirection,  bestIterPointResidual = x.copy(),  f_new,  g2.copy(),  mr_new
-
-                        g2 = self.__getRalgDirection__(x, p)
-
-                        if sum(p.dotmult(g1,g2))>0 or mr_new > mr_prev or f_new > f_prev or \
-                        abs(f_new - f_no_backward) < 15 * p.ftol or p.norm(x - x_no_backward) < 15 * p.xtol:
-                            x, hs, g2 = x_prev, hs_prev, g2_prev
+                        newPoint = p.point(x)
+
+                        if newPoint.mr() > PrevPoint.mr() or newPoint.f() > PrevPoint.f() or abs(newPoint.f() - iterPoint.f()) < 15 * p.ftol or p.norm(newPoint.x - iterPoint.x) < 15 * p.xtol:
+                            iterPoint, hs = PrevPoint, hs_prev
                             break
+
+                        PrevPoint = newPoint
+
                         ls -= 1
-                        if itn != 0: break
-
-                    xk, fk = x.copy(), p.f(x)
+                        if itn != 0:
+                            break
+                    iterPoint = PrevPoint
+
+            x = iterPoint.x.copy()
+            fk,  xk,  rk = iterPoint.f(),  x.copy(),  iterPoint.mr()
 
             if ls <= 0: hs *= q1
 
             prevIterPointIsFeasible = p.iterValues.r[-1] <= p.contol # p.iterValues.r is max residual defined in ooIter.py
-            currIterPointIsFeasible = p.getMaxResidual(x) <= p.contol
-
+            currIterPointIsFeasible = p.isFeas(x)
+
+            g2 = self.__getRalgDirection__(x, p)
             if prevIterPointIsFeasible == currIterPointIsFeasible == True:
                 g1 = g2 - g
@@ -197 +193 @@
             p._df = g2.copy()
 
-            if not self.needRej(p, b, g):
+            if not self.needRej(p, b, g1, g):
                 if all(isfinite(g)) and ng > 1e-50 and doDilation:
                     g = (g / ng).reshape((-1,1))
@@ -209 +205 @@
                 #hs = max(p.norm(xPrevIter - x), hsmin)
 
+            #xk, fk, rk = iterPoint.x, iterPoint.f(), iterPoint.mr()
             p.iterfcn(xk,  fk)
 
@@ -233 +230 @@
 
             if p.istop:
-#                p.xf = bestIterPoint
-#                p.ff = bestIterPointF
-                #p.advanced.ralg.hs = max(norm(xPrevIter - x), hsmin)
-                #p._df = _df
                 return
-#            x = bestIterPoint.copy()
-#            g = bestIterPointDirection.copy()
-#            if p.norm(x-bestIterPoint) < p.norm(bestIterPoint-xPrevIter):
-#                x = bestIterPoint.copy()
-#                ####g = bestIterPointDirection.copy()
-#                #g,  fname,  ind = self.__getRalgDirection__(x,  p)
-#            else:
-#                x = (x+xPrevIter) / 2.0
-                #g,  fname,  ind = self.__getRalgDirection__(x,  p)
-#            if dot(g2,  bestIterPointDirection) > 0:
-#                g = bestIterPointDirection.copy()
-#            else:
-#                g = g2.copy()
+
             g = g2.copy()
             xPrevIter = x.copy()