Changeset 1091

Show
Ignore:
Timestamp:
07/03/08 15:21:41 (2 months ago)
Author:
dmitrey.kroshko
Message:

lots of changes, mostly code cleanup, some minor bugfixes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/openopt/scikits/openopt/Kernel/BaseAlg.py

    r1089 r1091  
    1111    __homepage__ = 'Undefined. Use web search' 
    1212    __info__ = 'None' 
    13     __constraintsThatCannotBeHandled__ = ['c', 'h', 'Aeq', 'A', 'lb', 'ub'] 
     13 
     14    # TODO: remove it 
     15    __constraintsThatCannotBeHandled__ = [] 
     16 
     17    __optionalDataThatCanBeHandled__ = [] 
    1418    __isIterPointAlwaysFeasible__ = lambda self, p: p.isUC#TODO: provide possibility of simple True, False 
    1519    __iterfcnConnected__ = False 

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

    r1089 r1091  
    33from oologfcn import * 
    44from ooGraphics import Graphics 
    5 from setDefaultIterFuncs import setDefaultIterFuncs 
     5from setDefaultIterFuncs import setDefaultIterFuncs, IS_MAX_FUN_EVALS_REACHED 
    66from objFunRelated import objFunRelated 
    77from Residuals import Residuals 
    …… 
    1212 
    1313ProbDefaults = {'diffInt': 1e-7,  'xtol': 1e-6,  'noise': 0} 
    14  
    1514from runProbSolver import runProbSolver 
    1615 
    17 class Check: 
    18     def __init__(self): 
    19         self.df = 0# check numerical & 
    20         self.dh = 0# user-supplied gradients 
    21         self.dc = 0 
    22         # lines with difference less than maxViolation will be not shown 
    23         self.maxViolation = 1e-5 
     16 
     17 
    2418 
    2519class user: 
    2620    def __init__(self): 
    2721        pass 
    28  
    29 class Parallel: 
    30     def __init__(self): 
    31         self.f = False# 0 - don't use parallel calclations, 1 - use 
    32         self.c = False 
    33         self.h = False 
    34         #others are under development 
    35         #TODO: add paralell func! 
    36         #self.parallel.fun = dfeval 
    3722 
    3823class oomatrix: 
    …… 
    4631        #return asarray(x) * asarray(y) 
    4732 
    48 class args: 
    49     def __init__(self): pass 
    50     f, c, h = (), (), () 
    51  
    5233class autocreate: 
    5334    def __init__(self): pass 
    5435 
    55 class BaseProblem(oomatrix, objFunRelated, Residuals, ooTextOutput, args): 
     36class BaseProblem(oomatrix, Residuals, ooTextOutput): 
    5637    def __init__(self): 
    5738        self.isObjFunValueASingleNumber = True 
    …… 
    6142        self.name = 'unnamed' 
    6243 
    63         self.check = Check() 
    64         self.parallel = Parallel() 
     44 
    6545        self.graphics = Graphics() 
    6646        self.user = user() 
    67         self.args = args() 
    6847 
    6948        self.plot = False # draw picture or not 
    …… 
    9574        self.data4TextOutput = ['objFunVal', 'log10(maxResidual)'] 
    9675 
    97         #TODO: remove it? 
    98         self.useScaling = 0#if 1, ScaleFactor or TypicalX must be provided, else x0 will be used as  TypicalX. However, OpenOpt automatic scaling isn't tested properly yet. 
    9976 
    10077        self.debug = 0 
    …… 
    10683 
    10784        self.maxIter = 400 
    108         self.maxFunEvals = 10000 
     85        self.maxFunEvals = 10000 # TODO: move it to NinLinProblem class? 
    10986        self.maxCPUTime = inf 
    11087        self.maxTime = inf 
    111         self.maxLineSearch = 500 
    112         self.xtol = ProbDefaults['xtol'] 
    113         self.gradtol = 1e-6 
     88        self.maxLineSearch = 500 # TODO: move it to NinLinProblem class? 
     89        self.xtol = ProbDefaults['xtol'] # TODO: move it to NinLinProblem class? 
     90        self.gradtol = 1e-6 # TODO: move it to NinLinProblem class? 
    11491        self.ftol = 1e-6 
    11592        self.contol = 1e-6 
    …… 
    12198        self.binVars = [] # for problems like MILP 
    12299 
    123         self.noise = ProbDefaults['noise'] 
    124         self.consMode = 'all' 
    125  
    126         #TODO: move it to non-lin funcs classes only 
    127         self.prevVal = {} 
    128         for fn in ['f', 'c', 'h', 'df', 'dc', 'dh', 'd2f', 'd2c', 'd2h']: 
    129             self.prevVal[fn] = {'key':None, 'val':None} 
     100        self.noise = ProbDefaults['noise'] # TODO: move it to NinLinProblem class? 
     101 
    130102 
    131103        # A * x <= b inequalities 
    …… 
    147119        # 0 : <Awhole, x> [j] = bwhole[j] 
    148120 
    149         #finite-difference gradient aproximation step 
    150         self.diffInt = ProbDefaults['diffInt'] 
    151  
    152121        self.scale = None 
    153  
    154         self.isVectoriezed = 0# isn't tested properly yet 
    155  
    156         #f0 = None#TODO: handle me properly 
    157  
    158         #non-linear constraints 
    159         self.c = None # c(x)<=0 
    160         self.h = None # h(x)=0 
    161122 
    162123        self.goal = None# should be redefined by child class 
    163124        # possible values: 'maximum', 'min', 'max', 'minimum', 'minimax' etc 
    164125        self.showGoal = False# can be redefined by child class, used for text & graphic output 
    165  
    166         # TODO: implement in a field self classification: 
    167         # 'minimax', 'multiobjective'(or goalattain?), etc 
    168  
    169         self.fPattern = None 
    170         self.cPattern = None 
    171         self.hPattern = None 
    172  
    173         ##primal.* fields are for OpenOpt developers only, not common users 
    174         #primal.f = None 
    175         #primal.df = None 
    176         #primal.d2f = None 
    177         #primal.c = None 
    178         #primal.h = None 
    179         #primal.dc = None 
    180         #primal.dh = None 
    181         #primal.d2c = None 
    182         #primal.d2h = None 
    183126 
    184127        self.color = 'b' # blue, color for plotting 
    …… 
    199142        # so it may be ignored with some solvers not closely connected to OO Kernel 
    200143 
    201         self.kernelIterFuncs = setDefaultIterFuncs() 
    202  
    203144        self.callback = [] 
    204145 
    …… 
    208149 
    209150        self.special = autocreate() 
     151 
     152        self.optionalData = []#string names of optional data like 'c', 'h', 'Aeq' etc 
     153 
     154    def __finalize__(self): 
     155        pass 
    210156 
    211157    def objFunc(self, x): 
    …… 
    224170        return self.b.size ==0 and self.beq.size==0 and not self.userProvided.c and not self.userProvided.h 
    225171 
    226     def __1stBetterThan2nd__(self,  f1, f2,  r1=None,  r2=None): 
    227         if self.isUC: 
    228             #TODO: check for goal = max/maximum 
    229             return f1 < f2 
    230         else:#then r1, r2 should be defined 
    231             return (r1 < r2 and  self.contol < r2) or (((r1 <= self.contol and r2 <=  self.contol) or r1==r2) and f1 < f2) 
    232  
    233     def __1stCertainlyBetterThan2ndTakingIntoAcoountNoise__(self,   f1, f2,  r1=None,  r2=None): 
    234         if self.isUC: 
    235             #TODO: check for goalType = max 
    236             return f1 + self.noise < f2 - self.noise 
    237         else: 
    238             #return (r1 + self.noise < r2 - self.noise and  self.contol < r2) or \ 
    239             return (r1 < r2  and  self.contol < r2) or \ 
    240             (((r1 <= self.contol and r2 <=  self.contol) or r1==r2) and f1 + self.noise < f2 - self.noise) 
     172#    def __1stBetterThan2nd__(self,  f1, f2,  r1=None,  r2=None): 
     173#        if self.isUC: 
     174#            #TODO: check for goal = max/maximum 
     175#            return f1 < f2 
     176#        else:#then r1, r2 should be defined 
     177#            return (r1 < r2 and  self.contol < r2) or (((r1 <= self.contol and r2 <=  self.contol) or r1==r2) and f1 < f2) 
     178# 
     179#    def __1stCertainlyBetterThan2ndTakingIntoAcoountNoise__(self,   f1, f2,  r1=None,  r2=None): 
     180#        if self.isUC: 
     181#            #TODO: check for goalType = max 
     182#            return f1 + self.noise < f2 - self.noise 
     183#        else: 
     184#            #return (r1 + self.noise < r2 - self.noise and  self.contol < r2) or \ 
     185#            return (r1 < r2  and  self.contol < r2) or \ 
     186#            (((r1 <= self.contol and r2 <=  self.contol) or r1==r2) and f1 + self.noise < f2 - self.noise) 
    241187 
    242188 
    …… 
    244190        return runProbSolver(self, solvers, *args, **kwargs) 
    245191 
     192 
     193    # TODO: remove it 
    246194    def auxFunc(self, x, *args, **kwargs): 
    247195        r = self.connectedIterFuncField(x, *args, **kwargs) 
    …… 
    253201        return r 
    254202 
     203    # TODO: simplify or remove it 
    255204    def connectIterFcn(self, funcname, calledByUser = True): 
    256205        #this function could be called by user or by RunProbSolver.py 
    …… 
    271220        self.err('OpenOpt error: this function should be overdetermined by child class') 
    272221 
     222    def inspire(self, newProb): 
     223        # fills some fields of new prob with old prob values 
     224 
     225        #TODO: hold it in single place 
     226        for key in ['lb', 'ub', 'A', 'Aeq', 'b', 'beq', 'contol', 'xtol', 'ftol', 'gradtol', 'iprint', 'plot', 'maxIter', 'maxTime', 'maxCPUTime','fEnough', 'goal', 'color', 'debug'] : 
     227            if hasattr(self, key): setattr(newProb, key, getattr(self, key)) 
     228 
     229 
     230class MatrixProblem(BaseProblem): 
     231    __baseClassName__ = 'Matrix' 
     232    def __init__(self): 
     233        BaseProblem.__init__(self) 
     234        self.kernelIterFuncs = setDefaultIterFuncs('Matrix') 
     235 
     236    def __prepare__(self): 
     237        pass 
     238 
     239class Check: 
     240    def __init__(self): 
     241        self.df = 0# check numerical & 
     242        self.dh = 0# user-supplied gradients 
     243        self.dc = 0 
     244        # lines with difference less than maxViolation will be not shown 
     245        self.maxViolation = 1e-5 
     246 
     247class Parallel: 
     248    def __init__(self): 
     249        self.f = False# 0 - don't use parallel calclations, 1 - use 
     250        self.c = False 
     251        self.h = False 
     252        #TODO: add paralell func! 
     253        #self.parallel.fun = dfeval 
     254 
     255class args: 
     256    def __init__(self): pass 
     257    f, c, h = (), (), () 
     258 
     259class NonLinProblem(BaseProblem, objFunRelated, args): 
     260    __baseClassName__ = 'NonLin' 
     261    def __init__(self): 
     262        BaseProblem.__init__(self) 
     263        self.check = Check() 
     264        self.args = args() 
     265        self.consMode = 'all' # TODO: remove it? 
     266        #self.parallel = Parallel() 
     267 
     268        self.prevVal = {} 
     269        for fn in ['f', 'c', 'h', 'df', 'dc', 'dh', 'd2f', 'd2c', 'd2h']: 
     270            self.prevVal[fn] = {'key':None, 'val':None} 
     271 
     272        #finite-difference gradient aproximation step 
     273        self.diffInt = ProbDefaults['diffInt'] 
     274 
     275        #self.isVectoriezed = False 
     276 
     277        #non-linear constraints 
     278        self.c = None # c(x)<=0 
     279        self.h = None # h(x)=0 
     280 
     281#        self.fPattern = None 
     282#        self.cPattern = None 
     283#        self.hPattern = None 
     284        self.kernelIterFuncs = setDefaultIterFuncs('NonLin') 
     285 
    273286    def checkdf(self, *args,  **kwargs): 
    274287        return ooCheckGradient(self, 'df', *args,  **kwargs) 
    …… 
    289302            if type(v) != type(()): setattr(self.args, j, (v,)) 
    290303 
    291     def inspire(self, newProb): 
    292         # fills some fields of new prob with old prob values 
    293  
    294         #TODO: hold it in single place 
    295         for key in ['lb', 'ub', 'A', 'Aeq', 'b', 'beq', 'contol', 'xtol', 'ftol', 'gradtol', 'iprint', 'plot', 'maxIter', 'maxTime', 'maxCPUTime','fEnough', 'goal', 'color', 'debug'] : 
    296             if hasattr(self, key): setattr(newProb, key, getattr(self, key)) 
     304    def __finalize__(self): 
     305        if (self.userProvided.c and any(isnan(self.c(self.xf)))) or (self.userProvided.h and any(isnan(self.h(self.xf)))): 
     306            if self.iprint >= -1: self.warn('some non-linear constraints are equal to NaN') 
     307 
     308    def __prepare__(self): 
     309        self.__makeCorrectArgs__() 
     310        for s in ('f', 'df', 'd2f', 'c', 'dc', 'd2c', 'h', 'dh', 'd2h'): 
     311            if hasattr(self, s) and getattr(self, s) is not None: 
     312                setattr(self.userProvided, s, True) 
     313                self.nEvals[s] = 0 
     314                A = getattr(self,s) 
     315 
     316                if callable(A): #TODO: add or ndarray(A)!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
     317                    A = (A,)#make tuple 
     318                setattr(self.user, s, A) 
     319            else: 
     320                setattr(self.userProvided, s, False) 
     321                #setattr(p.user, s, (None,)) 
     322            setattr(self, s, getattr(self, 'user_' + s)) 
     323 
     324        #initialization, getting nf, nc, nh etc: 
     325        for s in ['c', 'h']: 
     326            if getattr(self.userProvided, s): 
     327                getattr(self, s)(self.x0) 
     328            else: 
     329                setattr(self, 'n'+s, 0) 
     330 
     331        if hasattr(self, 'delayedConnectIterFcn'): 
     332            if self.solver.__iterfcnConnected__: self.warn('solver ' + self.solver.__name__ + ' has native iterfcn, user-defined connection via p.connectIterFcn will be ignored') 
     333            else: 
     334                if self.delayedConnectIterFcn == 'df': self.warn('iterfcn now connects to df automatically by default, you can either use other funcs like d2f to suppress the warning or ommit user-defined connecting to df at all') 
     335                self.connectIterFcn('df') 
     336        else: 
     337            if not self.solver.__iterfcnConnected__: 
     338                self.connectIterFcn('df', calledByUser = False) 

  • trunk/openopt/scikits/openopt/Kernel/GLP.py

    r1040 r1091  
    11from ooMisc import assignScript 
    2 from BaseProblem import BaseProblem 
     2from BaseProblem import NonLinProblem 
    33from numpy import asarray, ones, inf, array, iterable 
    44from NLP import nlp_init 
    55 
    6 class GLP(BaseProblem): 
     6class GLP(NonLinProblem): 
     7    __optionalData__ = ['lb', 'ub'] 
    78    def __init__(self, *args, **kwargs): 
    89        if len(args) > 1: self.err('incorrect args number for GLP constructor, must be 0..1 + (optionaly) some kwargs') 
    …… 
    1011        kwargs2 = kwargs.copy() 
    1112        if len(args) > 0: kwargs2['f'] = args[0] 
    12         BaseProblem.__init__(self) 
     13        NonLinProblem.__init__(self) 
    1314 
    1415        glp_init(self, kwargs2) 

  • trunk/openopt/scikits/openopt/Kernel/LLSP.py

    r1040 r1091  
    11from ooMisc import assignScript 
    2 from BaseProblem import BaseProblem 
    3 from numpy import asfarray, ones, inf, dot 
     2from BaseProblem import MatrixProblem 
     3from numpy import asfarray, ones, inf, dot, nan, zeros 
    44from numpy.linalg import norm 
     5import NLP 
    56 
    6 class LLSP(BaseProblem): 
     7class LLSP(MatrixProblem): 
     8    __optionalData__ = ['damp', 'xd', 'c'] 
    79    def __init__(self, *args, **kwargs): 
    810        if len(args) > 2: self.err('incorrect args number for LLSP constructor, must be 0..2 + (optionaly) some kwargs') 
    911        if len(args) > 0: kwargs['C'] = args[0] 
    1012        if len(args) > 1: kwargs['d'] = args[1] 
    11         BaseProblem.__init__(self) 
     13 
     14        MatrixProblem.__init__(self) 
    1215        llsp_init(self, kwargs) 
    1316 
    1417    def objFunc(self, x): 
    15         return norm(dot(self.C, x) - self.d) 
     18        r = norm(dot(self.C, x) - self.d) ** 2  /  2.0 
     19        if self.damp != 0: r += self.damp * norm(x-self.xd)**2 / 2.0 
     20        if any(self.f): r += dot(self.f, x) 
     21        return r 
     22 
     23    def llsp2nlp(self, solver, **kwargs): 
     24        if hasattr(self,'x0'): p = NLP.NLP(ff, self.x0, df=dff) 
     25        else: p = NLP(ff, zeros(self.n), df=dff) 
     26        p.args.f = self # DO NOT USE p.args = self IN PROB ASSIGNMENT! 
     27        self.inspire(p) 
     28        r = p.solve(solver, **kwargs) 
     29        return r 
     30 
     31 
    1632 
    1733def llsp_init(prob, kwargs): 
    …… 
    2642    prob.lb = -inf * ones(prob.n) 
    2743    prob.ub =  inf * ones(prob.n) 
     44    if not kwargs.has_key('damp'): kwargs['damp'] = 0 
     45    if not kwargs.has_key('xd'): kwargs['xd'] = zeros(prob.n) 
     46    if not kwargs.has_key('f'): kwargs['f'] = zeros(prob.n) 
     47 
     48    if prob.x0 is nan: prob.x0 = zeros(prob.n) 
    2849 
    2950    return assignScript(prob, kwargs) 
    3051 
     52#def ff(x, LLSPprob): 
     53#    r = dot(LLSPprob.C, x) - LLSPprob.d 
     54#    return dot(r, r) 
     55ff = lambda x, LLSPprob: LLSPprob.objFunc(x) 
     56dff = lambda x, LLSPprob: 2 * (dot(LLSPprob.C.T, dot(LLSPprob.C,x)  - LLSPprob.d)) 
     57 

  • trunk/openopt/scikits/openopt/Kernel/LP.py

    r1040 r1091  
    11from ooMisc import assignScript 
    2 from BaseProblem import BaseProblem 
    3 from numpy import asarray, ones, inf 
     2from BaseProblem import MatrixProblem 
     3from numpy import asarray, ones, inf, dot, nan, zeros 
    44 
    55 
    6 class LP(BaseProblem): 
     6class LP(MatrixProblem): 
     7    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub'] 
    78    def __init__(self, *args, **kwargs): 
    89        kwargs2 = kwargs.copy() 
    …… 
    1011        if len(args) > 1: self.err('incorrect args number for LP constructor, must be 0..1 + (optionaly) some kwargs') 
    1112        self.probType = 'LP' 
    12         BaseProblem.__init__(self) 
     13        MatrixProblem.__init__(self) 
    1314        lp_init(self, kwargs2) 
    1415 
    1516 
    1617    def objFunc(self, x): 
    17         return self.dotmult(p.f, x) 
     18        return dot(self.f, x) 
    1819 
    1920def lp_init(prob, kwargs): 
    …… 
    2728 
    2829    prob.n = len(f) 
     30    if prob.x0 is nan: prob.x0 = zeros(prob.n) 
    2931    prob.lb = -inf * ones(prob.n) 
    3032    prob.ub =  inf * ones(prob.n) 

  • trunk/openopt/scikits/openopt/Kernel/LSP.py

    r830 r1091  
    1 from BaseProblem import BaseProblem 
     1from BaseProblem import NonLinProblem 
    22from NLP import nlp_init 
    33 
    4 class LSP(BaseProblem): 
     4class LSP(NonLinProblem): 
     5    __optionalData__ = [] 
    56    def __init__(self, *args, **kwargs): 
    67        if len(args) > 2: self.err('incorrect args number for LSP constructor, must be 0..2 + (optionaly) some kwargs') 
    7          
     8 
    89        kwargs2 = kwargs.copy() 
    910        if len(args) > 0: kwargs2['f'] = args[0] 
    1011        if len(args) > 1: kwargs2['x0'] = args[1] 
    11          
    12         BaseProblem.__init__(self) 
     12 
     13        NonLinProblem.__init__(self) 
    1314        self.probType = 'LSP' 
     15        self.allowedGoals = ['minimum', 'min'] 
    1416        self.isObjFunValueASingleNumber = False 
    15          
     17 
    1618        return nlp_init(self, kwargs2) 
    1719 

  • trunk/openopt/scikits/openopt/Kernel/MILP.py

    r1040 r1091  
    11 
    22from ooMisc import assignScript 
    3 from BaseProblem import BaseProblem 
    4 from numpy import asarray, ones, inf 
     3from BaseProblem import MatrixProblem 
     4from numpy import asarray, ones, inf, dot, nan, zeros 
    55 
    66from LP import lp_init 
    …… 
    88 
    99 
    10 class MILP(BaseProblem): 
     10class MILP(MatrixProblem): 
     11    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub'] 
    1112    def __init__(self, *args, **kwargs): 
    1213        if len(args) > 2: self.err('incorrect args number for MILP constructor, must be 0..2 + (optionaly) some kwargs') 
    …… 
    1617        if len(args) > 1: kwargs2['intVars'] = args[1] 
    1718        self.probType = 'MILP' 
    18         BaseProblem.__init__(self) 
     19        MatrixProblem.__init__(self) 
    1920        lp_init(self, kwargs2) 
     21 
     22    def objFunc(self, x): 
     23        return dot(self.f, x) 
    2024 
    2125 
    2226 
    23  
    24  

  • trunk/openopt/scikits/openopt/Kernel/MMP.py

    r1040 r1091  
    1 from BaseProblem import BaseProblem 
     1from BaseProblem import NonLinProblem 
    22from NLP import nlp_init 
    33from numpy import max 
    44 
    5 class MMP(BaseProblem): 
     5class MMP(NonLinProblem): 
    66    """ 
    77    Mini-Max Problem 
    88    """ 
     9    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub', 'c', 'h'] 
    910    def __init__(self, *args, **kwargs): 
    1011        if len(args) > 2: self.err('incorrect args number for MMP constructor, must be 0..2 + (optionaly) some kwargs') 
    …… 
    1314        if len(args) > 0: kwargs2['f'] = args[0] 
    1415        if len(args) > 1: kwargs2['x0'] = args[1] 
    15         BaseProblem.__init__(self) 
     16        NonLinProblem.__init__(self) 
    1617 
    17         self.allowedGoals = ['minimum', 'min', 'maximum', 'max'] 
     18        self.allowedGoals = ['minimax'] 
    1819 
    1920        nlp_init(self, kwargs2) 

  • trunk/openopt/scikits/openopt/Kernel/NLP.py

    r1040 r1091  
    11from ooMisc import assignScript 
    2 from BaseProblem import BaseProblem 
     2from BaseProblem import NonLinProblem 
    33from numpy import asarray, ones, inf, array, iterable 
    44 
    55 
    6 class NLP(BaseProblem): 
     6class NLP(NonLinProblem): 
     7    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub', 'c', 'h'] 
    78    def __init__(self, *args, **kwargs): 
    89        if len(args) > 2: self.err('incorrect args number for NLP constructor, must be 0..2 + (optionaly) some kwargs') 
    …… 
    1112        if len(args) > 0: kwargs2['f'] = args[0] 
    1213        if len(args) > 1: kwargs2['x0'] = args[1] 
    13         BaseProblem.__init__(self) 
     14        NonLinProblem.__init__(self) 
    1415 
    1516        self.probType = 'NLP' 

  • trunk/openopt/scikits/openopt/Kernel/NLSP.py

    r1040 r1091  
    1 from BaseProblem import BaseProblem 
     1from BaseProblem import NonLinProblem 
    22from NLP import nlp_init 
    33from numpy.linalg import norm 
    …… 
    55from setDefaultIterFuncs import FVAL_IS_ENOUGH 
    66 
    7 class NLSP(BaseProblem): 
     7class NLSP(NonLinProblem): 
     8    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub', 'c', 'h'] 
    89    def __init__(self, *args, **kwargs): 
    910        if len(args) > 2: self.err('incorrect args number for NLSP constructor, must be 0..2 + (optionaly) some kwargs') 
    …… 
    1213        if len(args) > 0: kwargs2['f'] = args[0] 
    1314        if len(args) > 1: kwargs2['x0'] = args[1] 
    14         BaseProblem.__init__(self) 
     15        NonLinProblem.__init__(self) 
    1516 
    1617        self.isObjFunValueASingleNumber = False 

  • trunk/openopt/scikits/openopt/Kernel/NSP.py

    r1040 r1091  
    11from ooMisc import assignScript 
    2 from BaseProblem import BaseProblem 
     2from BaseProblem import NonLinProblem 
    33from numpy import asarray, ones, inf 
    44 
    …… 
    77 
    88 
    9 class NSP(BaseProblem): 
     9class NSP(NonLinProblem): 
     10    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub', 'c', 'h'] 
    1011    def __init__(self, *args, **kwargs): 
    1112        if len(args) > 2: self.err('incorrect args number for NSP constructor, must be 0..2 + (optionaly) some kwargs') 
    …… 
    1415        if len(args) > 0: kwargs2['f'] = args[0] 
    1516        if len(args) > 1: kwargs2['x0'] = args[1] 
    16         BaseProblem.__init__(self) 
     17        NonLinProblem.__init__(self) 
    1718 
    1819 

  • trunk/openopt/scikits/openopt/Kernel/QP.py

    r1089 r1091  
    66 
    77from ooMisc import assignScript 
    8 from BaseProblem import BaseProblem 
     8from BaseProblem import MatrixProblem 
    99from numpy import asfarray, ones, inf, dot, asfarray, nan, zeros 
    1010 
    1111 
    12 class QP(BaseProblem): 
     12class QP(MatrixProblem): 
     13    __optionalData__ = ['A', 'Aeq', 'b', 'beq', 'lb', 'ub'] 
    1314    def __init__(self, *args, **kwargs): 
    1415        self.probType = 'QP' 
    …… 
    1718        if len(args) > 1: kwargs2['f'] = args[1] 
    1819        if len(args) > 2: self.err('incorrect args number for QP constructor, must be 0..1 + (optionaly) some kwargs') 
    19         BaseProblem.__init__(self) 
     20        MatrixProblem.__init__(self) 
    2021 
    2122        return qp_init(self, kwargs2) 

  • trunk/openopt/scikits/openopt/Kernel/Residuals.py

    r1089 r1091  
    3636        # TODO: add quadratic constraints 
    3737        r = EmptyClass() 
    38         r.c = self.__get_nonLinInEq_Residuals__(x) 
    39         r.h = self.__get_nonLinEq_Residuals__(x) 
     38        # TODO: simplify it! 
     39        if self.__baseClassName__ == 'NonLin': 
     40            r.c = self.__get_nonLinInEq_Residuals__(x) 
     41            r.h = self.__get_nonLinEq_Residuals__(x) 
     42        else: 
     43            r.c = r.h = 0 
    4044        r.A = self.__get_AX_Less_B_Residuals__(x) 
    4145        r.Aeq= self.__get_AeqX_eq_Beq_Residuals__(x) 

  • trunk/openopt/scikits/openopt/Kernel/objFunRelated.py

    r1009 r1091  
    167167    def wrapped_1st_derivatives(p, funcType, x, ind=None, ignorePrev=False): 
    168168        derivativesType = 'd'+funcType 
    169         funcs = getattr(p.user, derivativesType) 
     169        #funcs = getattr(p.user, derivativesType) 
    170170        prevKey = p.prevVal[derivativesType]['key'] 
    171171        if prevKey is not None and p.iter > 0 and all(x == prevKey) and ind is None and not ignorePrev: 

  • trunk/openopt/scikits/openopt/Kernel/ooCheck.py

    r1064 r1091  
    1111        p.err('goal '+ p.goal+' is not available for the '+ p.probType + ' class (at least not implemented yet)') 
    1212 
    13  
     13#    for fn in p.__optionalData__: 
     14#        if not fn in p.solver.__optionalDataThatCanBeHandled__: 
     15#            p.err('the solver ' + p.solverName + ' cannot handle ' + "'" + fn + "' data") 
    1416 
    1517    if p.solver.__constraintsThatCannotBeHandled__ != []: 
    …… 
    2022                    p.err('the solver ' + p.solverName + ' cannot handle ' + "'" + fn + "' constraints") 
    2123 
    22     for fn in ('df', 'dc', 'dh'): 
    23         if getattr(p.check, fn): 
    24             p.info('the option p.check.'+fn+' is obsolete, use p.check'+fn+'() or p.check'+fn+'(x) instead') 
    2524 
    2625    return nErrors 

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

    r1090 r1091  
    8484    if p.graphics.xlabel == 'nf': p.iterValues.nf = [] # iter ObjFunc evaluation number 
    8585 
    86     p.__makeCorrectArgs__() 
     86    p.__prepare__() 
    8787 
    8888    if p.probType in ('LP', 'MILP', 'QP') and p.plot: 
    …… 
    9393    if hasattr(p, 'x0'): p.x0 = atleast_1d(asfarray(p.x0).copy()) 
    9494    for fn in ['lb', 'ub', 'b', 'beq', 'scale', 'diffInt']: 
    95         fv = getattr(p, fn) 
    96         if fv != None:# and fv != []: 
    97             setattr(p, fn, asfarray(fv, dtype='float').flatten()) 
    98         elif fn != 'scale': 
    99             setattr(p, fn, asfarray([])) 
    100  
    101  
    102     if p.scale is not None: 
     95        if hasattr(p, fn): 
     96            fv = getattr(p, fn) 
     97            if fv != None:# and fv != []: 
     98                setattr(p, fn, asfarray(fv, dtype='float').flatten()) 
     99            elif fn != 'scale': 
     100                setattr(p, fn, asfarray([])) 
     101 
     102 
     103    if p.scale is not None and hasattr(p, 'diffInt'): 
    103104        if p.diffInt.size>1 or p.diffInt[0] != ProbDefaults['diffInt']: 
    104105            p.info('using both non-default scale & diffInt is not recommended. diffInt = diffInt/scale will be used') 
    …… 
    125126    p.stopdict = {} 
    126127 
    127     for s in ('f', 'df', 'd2f', 'c', 'dc', 'd2c', 'h', 'dh', 'd2h', 'l', 'dl', 'd2l'): 
    128         if not (s == 'f' and p.probType in ('LP', 'MILP', 'QP')): 
    129             if hasattr(p, s) and getattr(p, s) is not None: 
    130                 setattr(p.userProvided, s, True) 
    131                 p.nEvals[s] = 0 
    132                 A = getattr(p,s) 
    133  
    134                 if callable(A): #TODO: add or ndarray(A)!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    135                     A = (A,)#make tuple 
    136                 setattr(p.user, s, A) 
    137             else: 
    138                 setattr(p.userProvided, s, False) 
    139                 setattr(p.user, s, (None,)) 
    140             setattr(p, s, getattr(p, 'user_' + s)) 
    141  
    142     #initialization, getting nf, nc, nh etc: 
    143     for s in ['c', 'h']: 
    144         if getattr(p.userProvided, s): 
    145             getattr(p, s)(p.x0) 
    146         else: 
    147             setattr(p, 'n'+s, 0) 
    148128    for s in ['b','beq']: 
    149129        if hasattr(p, s): setattr(p, 'n'+s, len(getattr(p, s))) 
    …… 
    158138    nErr = ooCheck(p) 
    159139    if nErr: p.err("prob check results: " +str(nErr) + "ERRORS!")#however, I guess this line will be never reached. 
    160  
    161     if hasattr(p, 'delayedConnectIterFcn'): 
    162         if p.solver.__iterfcnConnected__: p.warn('solver ' + p.solver.__name__ + ' has native iterfcn, user-defined connection via p.connectIterFcn will be ignored') 
    163         else: 
    164             if p.delayedConnectIterFcn == 'df': p.warn('iterfcn now connects to df automatically by default, you can either use other funcs like d2f to suppress the warning or ommit user-defined connecting to df at all') 
    165             p.connectIterFcn('df') 
    166     else: 
    167         if not p.solver.__iterfcnConnected__: 
    168             p.connectIterFcn('df', calledByUser = False) 
    169140 
    170141    if not p.solver.__iterfcnConnected__: 
    …… 
    226197    else: p.iterfcn(p.xf, p.ff) 
    227198 
    228     if (p.userProvided.c and any(isnan(p.c(p.xf)))) or (p.userProvided.h and any(isnan(p.h(p.xf)))): 
    229         #p. 
    230         if p.iprint >= -1: p.warn('some non-linear constraints are equal to NaN') 
     199    p.__finalize__() 
    231200 
    232201    r = OpenOptResult() 

  • trunk/openopt/scikits/openopt/Kernel/setDefaultIterFuncs.py

    r960 r1091  
    1313IS_NAN_IN_X = -4 
    1414IS_LINE_SEARCH_FAILED = -5 
    15 IS_MAX_ITER_REACHED = -7     
     15IS_MAX_ITER_REACHED = -7 
    1616IS_MAX_CPU_TIME_REACHED = -8 
    1717IS_MAX_TIME_REACHED = -9 
    …… 
    2020 
    2121FAILED_WITH_UNIMPLEMENTED_OR_UNKNOWN_REASON = -1000 
    22          
     22 
    2323def stopcase(arg): 
    2424    if hasattr(arg, 'istop'): istop = arg.istop 
    2525    else: istop = arg 
    26      
     26 
    2727    if istop > 0: return 1 
    2828    elif istop in [IS_MAX_ITER_REACHED, IS_MAX_CPU_TIME_REACHED, IS_MAX_TIME_REACHED, IS_MAX_FUN_EVALS_REACHED]: return 0 
    2929    else: return -1 
    30          
    3130 
    3231 
    33 def setDefaultIterFuncs(): 
     32 
     33def setDefaultIterFuncs(className): 
    3434    d = dict() 
    35      
     35 
    3636    # positive: 
    3737    d[SMALL_DF] = lambda p: small_df(p) 
    …… 
    4646    d[IS_MAX_CPU_TIME_REACHED]  = lambda p: isMaxCPUTimeReached(p) 
    4747    d[IS_MAX_TIME_REACHED]  = lambda p: isMaxTimeReached(p) 
    48     d[IS_MAX_FUN_EVALS_REACHED] = lambda p: isMaxFunEvalsReached(p) 
     48    if className == 'NonLin': d[IS_MAX_FUN_EVALS_REACHED] = lambda p: isMaxFunEvalsReached(p) 
    4949    return d 
    5050 
    5151def small_df(p): 
    52     if not hasattr(p, '_df') or p._df == None or p.norm(p._df) >= p.gradtol: return False  
     52    if not hasattr(p, '_df') or p._df == None or p.norm(p._df) >= p.gradtol: return False 
    5353    return (True, '|| gradient F(X[k]) || < gradtol') 
    5454    #return False if not hasattr(p, 'dF') or p.dF == None or p.norm(p.dF) > p.gradtol else True 
    55          
     55 
    5656def small_deltaX(p): 
    5757    if p.iter == 0: return False 
    …… 
    6161    else: return (True, '|| X[k] - X[k-1] || < xtol') 
    6262    #r = False if p.norm(p.xk - p.x_prev) > p.xtol else True 
    63      
    64          
     63 
     64 
    6565def small_deltaF(p): 
    6666    if p.iter == 0: return False 
    6767    #r = False if p.norm(p.fk - p.f_prev) > p.ftol else True 
    68     if  p.norm(p.iterValues.f[-1] - p.iterValues.f[-2]) >= p.ftol: # or (p.iterValues.r[-1] > p.contol and p.iterValues.r[-1] - p.iterValues.r[-2] < p.contol):  
     68    if  p.norm(p.iterValues.f[-1] - p.iterValues.f[-2]) >= p.ftol: # or (p.iterValues.r[-1] > p.contol and p.iterValues.r[-1] - p.iterValues.r[-2] < p.contol): 
    6969            return False 
    7070    else: return (True, '|| F[k] - F[k-1] || < ftol') 
    71      
     71 
    7272 
    7373def isEnough(p): 
    …… 
    8080       return (True, 'NaN in X[k] coords has been obtained') 
    8181    else: return False 
    82      
     82 
    8383 
    8484def isMaxIterReached(p): 
    …… 
    102102def isMaxFunEvalsReached(p): 
    103103    #if not hasattr(p, 'nFunEvals'): p.warn('no nFunEvals field'); return 0 
    104     if p.nEvals['f'] < p.maxFunEvals: 
     104    if p.nEvals['f'] >= p.maxFunEvals: 
     105        return (True, 'max objfunc evals limit has been reached') 
     106    else: 
    105107        return False 
    106     else:  
    107         return (True, 'max objfunc evals limit has been reached') 
    108108 
    109109 

  • trunk/openopt/scikits/openopt/solvers/BrasilOpt/ALGENCAN_oo.py