def _Prepare(self): if self._lp_prepared: return self._lp_prepared = True MatrixProblem._Prepare(self) if self.x0 is None: self.x0 = zeros(self.n) if hasattr(self.f, 'is_oovar'): # hence is oofun or oovar # freeVars and fixedVars are already rendered to both not-None here (if it's the case) # but current .D() implementation doesn't allow to use both arguments # BTW translator ignores fixed vars in derivatives, so passing fixedVars here can be omitted # but is performed for more safety wrt future changes _f = self._point2vector(self.f.D(self._x0, fixedVars = self.fixedVars)) self.f, self._f = _f, self.f self.user.f = (self._f, ) self._init_f_vector = _f # we don't take p.goal into account here _c = self._f(self._x0) - dot(self.f, self.x0) self._c = _c else: self._init_f_vector = self.f # we don't take p.goal into account here self._c = 0 self.f = atleast_1d(self.f) if not hasattr(self, 'n'): self.n = len(self.f) #print 'lb:', self.lb, 'ub:', self.ub if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n) if not hasattr(self, 'ub'): self.ub = inf * ones(self.n) # if any(isnan(self.lb)): # if self.lb.size != 1: self.err('NaN in lower bound for a variable from the problem') # self.lb = -inf * ones(self.n) # if any(isnan(self.ub)): # if self.ub.size != 1: self.err('NaN in upper bound for a variable from the problem') # self.ub = inf * ones(self.n) if self.goal in ['max', 'maximum']: self.f = -asfarray(self.f)
def _Prepare(self): if self._lp_prepared: return self._lp_prepared = True MatrixProblem._Prepare(self) if self.x0 is None: self.x0 = zeros(self.n) if hasattr(self.f, 'is_oovar'): # hence is oofun or oovar # freeVars and fixedVars are already rendered to both not-None here (if it's the case) # but current .D() implementation doesn't allow to use both arguments # BTW translator ignores fixed vars in derivatives, so passing fixedVars here can be omitted # but is performed for more safety wrt future changes _f = self._point2vector( self.f.D(self._x0, fixedVars=self.fixedVars)) self.f, self._f = _f, self.f self.user.f = (self._f, ) self._init_f_vector = _f # we don't take p.goal into account here _c = self._f(self._x0) - dot(self.f, self.x0) self._c = _c else: self._init_f_vector = self.f # we don't take p.goal into account here self._c = 0 self.f = atleast_1d(self.f) if not hasattr(self, 'n'): self.n = len(self.f) #print 'lb:', self.lb, 'ub:', self.ub if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n) if not hasattr(self, 'ub'): self.ub = inf * ones(self.n) # if any(isnan(self.lb)): # if self.lb.size != 1: self.err('NaN in lower bound for a variable from the problem') # self.lb = -inf * ones(self.n) # if any(isnan(self.ub)): # if self.ub.size != 1: self.err('NaN in upper bound for a variable from the problem') # self.ub = inf * ones(self.n) if self.goal in ['max', 'maximum']: self.f = -asfarray(self.f)
def __init__(self, *args, **kw): self.goal = 'min' self.bins = {} #self.objective = '' MatrixProblem.__init__(self, *args, **kw) self.__init_kwargs = kw self._init = True
def __init__(self, *args, **kwargs): if len(args) > 2: self.err('incorrect args number for LLAVP constructor, must be 0..2 + (optionaly) some kwargs') if len(args) > 0: kwargs['C'] = args[0] if len(args) > 1: kwargs['d'] = args[1] MatrixProblem.__init__(self) llavp_init(self, kwargs)
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) self.n = self.C.shape[1] # if 'damp' not in kwargs.keys(): kwargs['damp'] = None # if 'X' not in kwargs.keys(): kwargs['X'] = nan*ones(self.n) if self.x0 is None: self.x0 = zeros(self.n)
def _Prepare(self): if self._isPrepared: return self._isPrepared = True if isinstance(self.d, dict): # FuncDesigner startPoint self.x0 = self.d MatrixProblem._Prepare(self) if self.isFDmodel: equations = self.C AsSparse = bool(self.useSparse) if type(self.useSparse) != str else self._useSparse() C, d = [], [] if len(self._fixedVars) < len(self._freeVars): Z = dict([(v, zeros_like(self._x0[v]) if v not in self._fixedVars else self._x0[v]) for v in self._x0.keys()]) else: Z = dict([(v, zeros_like(self._x0[v]) if v in self._freeVars else self._x0[v]) for v in self._x0.keys()]) #Z = self.x0#self._vector2point(zeros(self.n)) for lin_oofun in equations: if lin_oofun.getOrder(self.freeVars, self.fixedVars) > 1: raise OpenOptException('SLE constructor requires all equations to be linear') C.append(self._pointDerivative2array(lin_oofun.D(Z, **self._D_kwargs), useSparse = AsSparse)) d.append(-lin_oofun(Z)) self.d = hstack(d).flatten() self.C = Vstack(C) if hasattr(self.C, 'tocsc'): self.C_as_csc = self.C.tocsc() if isinstance(self.C,ndarray) and self.n > 100 and len(flatnonzero(self.C))/self.C.size < 0.3: s = "Probably you'd better solve this SLE as sparse" if not scipyInstalled: s += ' (requires scipy installed)' self.pWarn(s) self.x0 = zeros(self.C.shape[1])
def __finalize__(self): MatrixProblem.__finalize__(self) if self.goal in ['max', 'maximum']: self.f = -self.f for fn in ['fk', ]:#not ff - it's handled in other place in RunProbSolver.py if hasattr(self, fn): setattr(self, fn, -getattr(self, fn))
def __init__(self, *args, **kwargs): self.goal = 'minimum' MatrixProblem.__init__(self, *args, **kwargs) if len(args) > 1 and not hasattr(args[0], 'is_oovar'): self.err( 'No more than 1 argument is allowed for classic style LP constructor' )
def _Prepare(self): if isinstance(self.d, dict): # FuncDesigner startPoint self.x0 = self.d MatrixProblem._Prepare(self) if self.isFDmodel: self.C, self.d = self._linearOOFunsToMatrices(self.C) if not self.damp is None and (not hasattr(self, 'X') or not any(isfinite(self.X))): self.X = zeros(self.n)
def _Prepare(self): MatrixProblem._Prepare(self) if self._isFDmodel(): C, d, q, s = renderFDmodel(self) self.C, self.d, self.q, self.s = C, d, q, s D = self.f.D(self._x0, fixedVars = self.fixedVars) _f = self._point2vector(D).flatten() self.f, self._f = _f, self.f
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if self._isFDmodel(): self.x0 = self.C return self.f = asfarray(self.f) self.n = self.f.size # for p.n to be available immediately after assigning prob if self.x0 is None: self.x0 = zeros(self.n)
def __init__(self, *args, **kwargs): self.probType = 'SDP' self.S = {} self.d = {} MatrixProblem.__init__(self, *args, **kwargs) self.f = asfarray(self.f) self.n = self.f.size if self.x0 is None: self.x0 = zeros(self.n)
def __init__(self, *args, **kwargs): if len(args) > 2: self.err( 'incorrect args number for LLAVP constructor, must be 0..2 + (optionaly) some kwargs' ) if len(args) > 0: kwargs['C'] = args[0] if len(args) > 1: kwargs['d'] = args[1] MatrixProblem.__init__(self) llavp_init(self, kwargs)
def __init__(self, *args, **kwargs): self.QC = [] MatrixProblem.__init__(self, *args, **kwargs) if self._isFDmodel(): if len(args) > 1: self.x0 = args[1] self.f = args[0] else: if len(args) > 1 or 'f' in kwargs.keys(): self.f = ravel(self.f)
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if len(args) > 1 or 'f' in kwargs.keys(): self.f = ravel(self.f) self.n = self.f.size if len(args) > 0 or 'H' in kwargs.keys(): # TODO: handle sparse cvxopt matrix H unchanges # if not ('cvxopt' in str(type(H)) and 'cvxopt' in p.solver): if not isspmatrix(self.H): self.H = asfarray(self.H, float) # TODO: handle the case in runProbSolver()
def __finalize__(self): MatrixProblem.__finalize__(self) if self.goal in ['max', 'maximum']: self.f = -self.f for fn in [ 'fk', ]: #not ff - it's handled in other place in RunProbSolver.py if hasattr(self, fn): setattr(self, fn, -getattr(self, fn)) if hasattr(self, '_f'): self.f = self._f
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if len(args) > 1 or 'f' in kwargs.keys(): self.f = ravel(self.f) self.n = self.f.size if len(args) > 0 or 'H' in kwargs.keys(): # TODO: handle sparse cvxopt matrix H unchanges # if not ('cvxopt' in str(type(H)) and 'cvxopt' in p.solver): if not isspmatrix(self.H): self.H = asfarray( self.H, float) # TODO: handle the case in runProbSolver()
def _Prepare(self): MatrixProblem._Prepare(self) if self.solver.__name__ in ['cvxopt_sdp', 'dsdp']: try: from cvxopt.base import matrix matrixConverter = lambda x: matrix(x, tc='d') except: self.err('cvxopt must be installed') else: matrixConverter = asfarray for i in self.S.keys(): self.S[i] = matrixConverter(self.S[i]) for i in self.d.keys(): self.d[i] = matrixConverter(self.d[i])
def solve(self, *args, **kw): C = self.C if type(C) in (tuple, list) and isinstance(C[0], dict): from FuncDesigner import ootranslator K = set() N = 0 varSizes = {} for d in C: K.update(d.keys()) for key in d.keys(): if key in varSizes: if varSizes[key] != d[key].shape[1]: s = 'incorrect shape 2nd coordinate %d for variable %s, defined in other array as %d' % ( d[key].shape[1], key.name, varSizes[key]) self.err(s) else: varSizes[key] = d[key].shape[1] if not isscalar( d[key]) else 1 tmp = list(d.values()) N += tmp[0].shape[0] if not isscalar(tmp[0]) else 1 P = dict([(key, [0] * val) for key, val in varSizes.items()]) T = ootranslator(P) C2 = vstack([T.pointDerivative2array(d) for d in C]) self.C = C2 if C2.shape != (N, N): self.err( 'square matrix of shape (%d,%d) expected, shape %s obtained instead' % (N, N, C2.shape)) r = MatrixProblem.solve(self, *args, **kw) if type(C) in (tuple, list) and isinstance(C[0], dict): r.eigenvectors = [T.vector2point(v) for v in self.eigenvectors.T] return r
def solve(self, *args, **kw): C = self.C if type(C) in (tuple, list) and isinstance(C[0], dict): from FuncDesigner import ootranslator K = set() N = 0 varSizes = {} for d in C: K.update(d.keys()) for key in d.keys(): if key in varSizes: if varSizes[key] != d[key].shape[1]: s = 'incorrect shape 2nd coordinate %d for variable %s, defined in other array as %d' %(d[key].shape[1], key.name, varSizes[key]) self.err(s) else: varSizes[key] = d[key].shape[1] if not isscalar(d[key]) else 1 tmp = list(d.values()) N += tmp[0].shape[0] if not isscalar(tmp[0]) else 1 P = dict([(key, [0]*val) for key, val in varSizes.items()]) T = ootranslator(P) C2 = vstack([T.pointDerivative2array(d) for d in C]) self.C = C2 if C2.shape != (N, N): self.err('square matrix of shape (%d,%d) expected, shape %s obtained instead' % (N, N, C2.shape)) r = MatrixProblem.solve(self, *args, **kw) if type(C) in (tuple, list) and isinstance(C[0], dict): r.eigenvectors = [T.vector2point(v) for v in self.eigenvectors.T] return r
def _Prepare(self): if not self._isFDmodel(): if not isspmatrix(self.H): self.H = asfarray( self.H) # TODO: handle the case in runProbSolver() self.n = self.H.shape[0] if not hasattr(self, 'x0') or self.x0 is None or self.x0[0] is nan: self.x0 = zeros(self.n) MatrixProblem._Prepare(self) if self._isFDmodel(): H, f, C = quad_render(self.H, self) self.user.f = (self.H, ) self.H, self.f, self.C = H, f, C # print(H, f, C) if self.fixedVars is None or (self.freeVars is not None and len( self.freeVars) < len(self.fixedVars)): order_kw = {'Vars': self.freeVarsSet} else: order_kw = {'fixedVars': self.fixedVarsSet} order_kw['fixedVarsScheduleID'] = self._FDVarsID from FuncDesigner import ooarray for c in self.constraints: if isinstance(c, ooarray): for elem in c: processConstraint(elem, order_kw, self) else: processConstraint(c, order_kw, self) r = [] for v in self._freeVarsList: if isinstance(v.domain, (tuple, list, ndarray, set)): self.err( 'for FuncDesigner MILP models only variables with domains int, bool or None (real) are implemented for now' ) if v.domain is int or v.domain is 'int' or v.domain is bool or v.domain is 'bool': r1, r2 = self._oovarsIndDict[v] r += arange(r1, r2).tolist() self.intVars, self._intVars = r, self.intVars self._intVars_vector = self.intVars
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if self.goal == 'all': Name, name = 'all eigenvectors and eigenvalues', 'all' if not isinstance(self.C[0], dict): self.N = self.C.shape[0] else: assert type(self.goal) in (dict, tuple, list) and len(self.goal) == 1, \ 'EIG goal argument should be "all" or Python dict {goal_name: number_of_required_eigenvalues}' if type(self.goal) == dict: goal_name, N = list(self.goal.items())[0] else: goal_name, N = self.goal self.N = N name = ''.join(goal_name.lower().split()) if name in ('lm', 'largestmagnitude'): Name, name = 'largest magnitude', 'le' elif name in ('sm', 'smallestmagnitude'): Name, name = 'smallest magnitude', 'sm' elif name in ('lr', 'largestrealpart'): Name, name = 'largest real part', 'lr' elif name in ('sr', 'smallestrealpart'): Name, name = 'smallest real part', 'sr' elif name in ('li', 'largestimaginarypart'): Name, name = 'largest imaginary part', 'li' elif name in ('si', 'smallestimaginarypart'): Name, name = 'smallest imaginary part', 'si' elif name in ('la', 'largestamplitude'): Name, name = 'largestamplitude', 'la' elif name in ('sa', 'smallestamplitude'): Name, name = 'smallest amplitude', 'sa' elif name in ('be', 'bothendsofthespectrum'): Name, name = 'both ends of the spectrum', 'be' self.goal = Name self._goal = name
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if 'damp' not in kwargs.keys(): self.damp = None if 'f' not in kwargs.keys(): self.f = None if not self._isFDmodel(): if len(args) > 0: self.n = args[0].shape[1] else: self.n = kwargs['C'].shape[1] #self.lb = -inf * ones(self.n) #self.ub = inf * ones(self.n) if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n) if not hasattr(self, 'ub'): self.ub = inf * ones(self.n) if self.x0 is None: self.x0 = zeros(self.n) else: # is FD model if type(self.C) not in (set, tuple, list): if 'is_oovar' not in dir(self.C): s = ''' Icorrect data type for LLSP constructor, first argument should be numpy ndarray, scipy sparse matrix, FuncDesigner oofun or list of oofuns''' self.err(s) self.C = [self.C]
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) if 'damp' not in kwargs.keys(): self.damp = None if 'f' not in kwargs.keys(): self.f = None if not self._isFDmodel(): if len(args)>0: self.n = args[0].shape[1] else: self.n = kwargs['C'].shape[1] #self.lb = -inf * ones(self.n) #self.ub = inf * ones(self.n) if not hasattr(self, 'lb'): self.lb = -inf * ones(self.n) if not hasattr(self, 'ub'): self.ub = inf * ones(self.n) if self.x0 is None: self.x0 = zeros(self.n) else: # is FD model if type(self.C) not in (set, tuple, list): if 'is_oovar' not in dir(self.C): s = ''' Icorrect data type for LLSP constructor, first argument should be numpy ndarray, scipy sparse matrix, FuncDesigner oofun or list of oofuns''' self.err(s) self.C = [self.C]
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) self.x0 = zeros(2 * len(self.q))
def _Prepare(self): MatrixProblem._Prepare(self) if not self.damp is None and not any(isfinite(self.X)): self.X = zeros(self.n)
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) self.f = asfarray(self.f) self.n = self.f.size # for p.n to be available immediately after assigning prob if self.x0 is None: self.x0 = zeros(self.n)
def __init__(self, *args, **kw): self.goal = 'max' self.objective = 'weight' MatrixProblem.__init__(self, *args, **kw) self.__init_kwargs = kw self._init = True
def __init__(self, *args, **kw): MatrixProblem.__init__(self, *args, **kw) self.__init_kwargs = kw self._init = True
def __init__(self, *args, **kwargs): MatrixProblem.__init__(self, *args, **kwargs) self.x0 = zeros(2*len(self.q))
def _Prepare(self): # TODO: handle cvxopt sparse matrix case here self.n = self.H.shape[0] if not hasattr(self, 'x0') or self.x0 is None or self.x0[0] == nan: self.x0 = zeros(self.n) MatrixProblem._Prepare(self)
def __finalize__(self): if self.isFDmodel: self.intVars = self._intVars MatrixProblem.__finalize__(self)
def __init__(self, *args, **kwargs): self.goal = 'minimum' MatrixProblem.__init__(self, *args, **kwargs) if len(args) > 1 and not hasattr(args[0], 'is_oovar'): self.err('No more than 1 argument is allowed for classic style LP constructor')