Changeset 433

Show
Ignore:
Timestamp:
02/16/10 14:31:50 (3 weeks ago)
Author:
dmitrey
Message:

some changes wrt individual contol for each FD constraint

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • PythonPackages/OpenOpt/openopt/kernel/baseProblem.py

    r427 r433  
    99 99  
    100 100     showFeas = False 
      101     useScaledResidualOutput = False 
    101 102  
    102 103     # A * x <= b inequalities 
     
    288 289                 areFixed = lambda dep: dep.isdisjoint(self._optVars) 
    289 290             self.theseAreFixed = areFixed 
      291              
      292             probtol = self.contol 
    290 293             
    291 294             for c in self.constraints: 
    292                   f = c.oofun 
      295                 if not hasattr(c, 'isConstraint'): self.err('The type' + str(type(c)) + 'is inappropriate for problem constraints') 
      296                  
      297                 f, tol = c.oofun, c.tol 
      298                 Name = f.name 
    293 299                 dep = f._getDep() 
    294 300                 if dep is None: # hence it's oovar 
    295 301                     assert f.is_oovar 
    296 302                     dep = set([f]) 
      303  
      304                 _lb, _ub = c.lb, c.ub 
      305                 if tol < 0: 
      306                     if any(_lb  == _ub): 
      307                         self.err("You can't use negative tolerance for the equality constraint " + c.name) 
      308                     elif any(_lb - tol >= _ub + tol): 
      309                         self.err("You can't use negative tolerance for so small gap in constraint" + c.name) 
      310  
      311                     Shift = (1.0+1e-13)*probtol  
      312                     ####################### 
      313                     # not inplace modification!!!!!!!!!!!!! 
      314                     _lb = _lb + Shift 
      315                     _ub = _ub - Shift 
      316                     ####################### 
      317                  
      318                 if tol != 0: self.useScaledResidualOutput = True 
      319                  
      320                 if tol not in (0, probtol, -probtol): 
      321                     f = f * abs(probtol / tol) 
      322                      
    297 323                 if areFixed(dep): 
    298 324                     # TODO: get rid of self.contol, use separate contols for each constraint 
    299                       if not c(self._x0, self.contol): 
      325                     Contol = c.contol if c.contol != 0 else self.contol 
      326                     if not c(self._x0, Contol): 
    300 327                         s = """'constraint "%s" with all-fixed optimization variables it depends on is infeasible in start point,  
    301 328                         hence the problem is infeasible, maybe you should change start point'""" % c.name 
     
    305 332                 if self.probType in ['LP', 'MILP', 'LLSP', 'LLAVP'] and not f.is_linear: 
    306 333                     self.err('for LP/MILP/LLSP/LLAVP all constraints have to be linear, while ' + f.name + ' is not') 
    307                   if not hasattr(c, 'isConstraint'): self.err('The type' + str(type(c)) + 'is inappropriate for problem constraints') 
      334                  
    308 335                      
    309                   if c.isBBC: # is BoxBoundConstraint 
    310                       oov = c.oofun 
    311                       Name = oov.name 
    312                       if oov in self._fixedVars:  
    313                           if self.x0 is None: self.err('your problem has fixed oovar '+ Name + ' but no start point is provided') 
      336                 # TODO: simplify condition of box-bounded oovar detection 
      337                 if f.is_oovar:# and not hasattr(c.lb, 'is_oovar') and not hasattr(c.ub, 'is_oovar'): # is BoxBoundConstraint 
      338                      
      339                     if f in self._fixedVars:  
      340                         if self.x0 is None: self.err('your problem has fixed oovar '+ Name + ' but no value for the one in start point is provided') 
    314 341                         continue 
    315                       inds = oovD[oov.name] 
    316                       oov_size = inds[1]-inds[0] 
    317                       _lb, _ub = c.lb, c.ub 
      342                     inds = oovD[Name] 
      343                     f_size = inds[1] - inds[0] 
      344  
    318 345                     if any(isfinite(_lb)): 
    319                           if _lb.size not in (oov_size, 1):  
    320                               self.err('incorrect size of lower box-bound constraint for %s: 1 or %d expected, %d obtained' % (Name, oov_size, _lb.size)) 
    321                           val = array(oov_size*[_lb] if _lb.size < oov_size else _lb) 
      346                         if _lb.size not in (f_size, 1):  
      347                             self.err('incorrect size of lower box-bound constraint for %s: 1 or %d expected, %d obtained' % (Name, f_size, _lb.size)) 
      348                         val = array(f_size*[_lb] if _lb.size < f_size else _lb) 
    322 349                         if Name not in LB.keys(): 
    323 350                             LB[Name] = val 
     
    325 352                             LB[Name] = max((val, LB[Name])) 
    326 353                     if any(isfinite(_ub)): 
    327                           if _ub.size not in (oov_size, 1):  
    328                               self.err('incorrect size of upper box-bound constraint for %s: 1 or %d expected, %d obtained' % (Name, oov_size, _ub.size)) 
    329                           val = array(oov_size*[_ub] if _ub.size < oov_size else _ub) 
      354                         if _ub.size not in (f_size, 1):  
      355                             self.err('incorrect size of upper box-bound constraint for %s: 1 or %d expected, %d obtained' % (Name, f_size, _ub.size)) 
      356                         val = array(f_size*[_ub] if _ub.size < f_size else _ub) 
    330 357                         if Name not in UB.keys(): 
    331 358                             UB[Name] = val 
    332 359                         else: 
    333 360                             UB[Name] = min((val, UB[Name])) 
    334                   elif c.lb == 0 and c.ub == 0
      361                 elif _lb == _ub
    335 362                     if f.is_linear: 
    336 363                         Aeq.append(self._pointDerivative2array(f.D(Z, **D_kwargs)))       
    337                           beq.append(-f(Z)
    338                       elif self.h is None: self.h = [c.oofun
    339                       else: self.h.append(c.oofun
    340                   elif c.ub == 0
      364                         beq.append(-f(Z)+_lb
      365                     elif self.h is None: self.h = [f+_lb
      366                     else: self.h.append(f+_lb
      367                 elif isfinite(_ub)
    341 368                     if f.is_linear: 
    342 369                         A.append(self._pointDerivative2array(f.D(Z, **D_kwargs)))                        
    343                           b.append(-f(Z)
    344                       elif self.c is None: self.c = [c.oofun
    345                       else: self.c.append(c.oofun
    346                   elif c.lb == 0
      370                         b.append(-f(Z)+_ub
      371                     elif self.c is None: self.c = [f - _ub
      372                     else: self.c.append(f - _ub
      373                 elif isfinite(_lb)
    347 374                     if f.is_linear: 
    348 375                         A.append(-self._pointDerivative2array(f.D(Z, **D_kwargs)))                        
    349                           b.append(f(Z))                         
    350                       elif self.c is None: self.c = [- c.oofun
    351                       else: self.c.append(- c.oofun
      376                         b.append(f(Z) - _lb)                         
      377                     elif self.c is None: self.c = [- f - _lb
      378                     else: self.c.append(- f - _lb
    352 379                 else: 
    353 380                     self.err('inform OpenOpt developers of the bug') 
     
    610 637         else: 
    611 638             p.err('ambiguous goal has been requested: function "minimize", goal: %s' %  kwargs['goal']) 
    612       p.goal = 'min
      639     p.goal = 'minimum
    613 640     return runProbSolver(p, *args, **kwargs) 
    614 641  
     
    619 646         else: 
    620 647             p.err('ambiguous goal has been requested: function "maximize", goal: %s' %  kwargs['goal']) 
    621       p.goal = 'max
      648     p.goal = 'maximum
    622 649     return runProbSolver(p, *args, **kwargs)             
  • PythonPackages/OpenOpt/openopt/kernel/graphics.py

    r291 r433  
    87 87             if not (p.__isUnconstrained__() or p.solver.__isIterPointAlwaysFeasible__(p)): 
    88 88                 self.isMaxConstraintSubplotRequired = True 
    89                   Y_LABELS.append('log10(maxConstraint)') 
      89                 if p.useScaledResidualOutput: 
      90                     Y_LABELS.append('log10(MaxConstraint/ConTol)') 
      91                 else: 
      92                     Y_LABELS.append('log10(maxConstraint)') 
    90 93             else: self.isMaxConstraintSubplotRequired = False 
    91 94  
     
    200 203         if self.isMaxConstraintSubplotRequired: 
    201 204             yy22 = log10(p.contol/self.REDUCE+asfarray(p.iterValues.r[IND_start:IND_end])) 
      205             if p.useScaledResidualOutput: yy22 -= log10(p.contol) 
    202 206             YY.append(yy22) 
    203 207             if IND_start<=IND_end: 
    204                   if len(p.iterValues.r) >= 1: yySave.append(log10(p.contol/self.REDUCE+asfarray(p.iterValues.r[-1]))) 
      208                 rr = p.iterValues.r[-1]  
      209                 if p.useScaledResidualOutput: rr -= log10(p.contol) 
      210                 if len(p.iterValues.r) >= 1: yySave.append(log10(p.contol/self.REDUCE+asfarray(rr))) 
    205 211                 else: 
    206 212                     yySave.append(log10(p.contol/self.REDUCE+asfarray(p.getMaxResidual(p.x0)))) 
     
    257 263                     if p.probType == 'NLSP': pylab.plot([xx[0]], [log10(p.ftol / self.REDUCE)],  color='w') 
    258 264             if ind == 1: 
    259                   pylab.plot([xx[0], xx[-1]], [log10(p.primalConTol), log10(p.primalConTol)], ls = self.axLineStyle, linewidth = self.axLineWidth, color='g',\ 
      265                 horz_line_value = 0 if p.useScaledResidualOutput else log10(p.primalConTol) 
      266                 pylab.plot([xx[0], xx[-1]], [horz_line_value, horz_line_value], ls = self.axLineStyle, linewidth = self.axLineWidth, color='g',\ 
    260 267                 marker = self.axMarker, ms = self.axMarkerSize, mew = self.markerEdgeWidth, mec = self.axMarkerEdgeColor, mfc = self.axFaceColor) 
    261 268             elif p.probType == 'NLSP': 
     
    307 314                         mew = self.markerEdgeWidth, mec = self.axMarkerEdgeColor, mfc = self.axFaceColor) 
    308 315                 if  ind == 1: 
    309                       pylab.plot([xmin, xmax], [log10(p.primalConTol), log10(p.primalConTol)],\ 
      316                     horz_line_value = 0 if p.useScaledResidualOutput else log10(p.primalConTol) 
      317                     pylab.plot([xmin, xmax], [horz_line_value, horz_line_value],\ 
    310 318                         linewidth = self.axLineWidth, ls = self.axLineStyle, color='g',\ 
    311 319                         marker = self.axMarker, ms = self.axMarkerSize, \ 
  • PythonPackages/OpenOpt/openopt/kernel/iterPrint.py

    r170 r433  
    9 9 'objFunVal': lambda p: p.iterObjFunTextFormat % (-p.fk if p.invertObjFunc else p.fk), \ 
    10 10 'log10(maxResidual)': lambda p: '%0.2f' % log10(p.rk+1e-100), \ 
      11 'log10(MaxResidual/ConTol)':lambda p: '%0.2f' % log10(max((p.rk/p.contol, 1e-100))), \ 
    11 12 'isFeasible': signOfFeasible 
    12 13 } 
  • PythonPackages/OpenOpt/openopt/kernel/runProbSolver.py

    r379 r433  
    150 150         assert p.data4TextOutput[-1] == 'log10(maxResidual)' 
    151 151         p.data4TextOutput = p.data4TextOutput[:-1] 
      152     elif p.useScaledResidualOutput: 
      153         p.data4TextOutput[-1] = 'log10(MaxResidual/ConTol)' 
    152 154  
    153 155     if p.showFeas and p.data4TextOutput[-1] != 'isFeasible': p.data4TextOutput.append('isFeasible')