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 _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 _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 _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 _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): 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.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 _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 _Prepare(self): MatrixProblem._Prepare(self) if not self.damp is None and not any(isfinite(self.X)): self.X = zeros(self.n)
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 _Prepare(self): MatrixProblem._Prepare(self) if not self.damp is None and not any(isfinite(self.X)): self.X = zeros(self.n)
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)