def test_mul_funcs(self): """Test functions to multiply by A, A.T """ n = 10 x = Variable(n) obj = Minimize(norm(x, 1)) constraints = [x >= 2] prob = Problem(obj, constraints) data, dims = prob.get_problem_data(solver=SCS) A = data["A"] objective, constraints = prob.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[SCS]) sym_data.constraints = prune_constants(sym_data.constraints) Amul, ATmul = iterative.get_mul_funcs(sym_data) vec = np.array(range(sym_data.x_length)) # A*vec result = np.zeros(A.shape[0]) Amul(vec, result) self.assertItemsAlmostEqual(A * vec, result) Amul(vec, result) self.assertItemsAlmostEqual(2 * A * vec, result) # A.T*vec vec = np.array(range(A.shape[0])) result = np.zeros(A.shape[1]) ATmul(vec, result) self.assertItemsAlmostEqual(A.T * vec, result) ATmul(vec, result) self.assertItemsAlmostEqual(2 * A.T * vec, result)
def test_mul_funcs(self): """Test functions to multiply by A, A.T """ n = 10 x = Variable(n) obj = Minimize(norm(x, 1)) constraints = [x >= 2] prob = Problem(obj, constraints) data = prob.get_problem_data(solver=SCS) A = data["A"] objective, constraints = prob.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[SCS]) sym_data.constraints = prune_constants(sym_data.constraints) Amul, ATmul = iterative.get_mul_funcs(sym_data) vec = np.array(range(sym_data.x_length)) # A*vec result = np.zeros(A.shape[0]) Amul(vec, result) self.assertItemsAlmostEqual(A * vec, result) Amul(vec, result) self.assertItemsAlmostEqual(2 * A * vec, result) # A.T*vec vec = np.array(range(A.shape[0])) result = np.zeros(A.shape[1]) ATmul(vec, result) self.assertItemsAlmostEqual(A.T * vec, result) ATmul(vec, result) self.assertItemsAlmostEqual(2 * A.T * vec, result)
def choose_solver(constraints): """Determines the appropriate solver. Parameters ---------- constraints: list The list of canonicalized constraints. Returns ------- str The solver that will be used. """ constr_map = SymData.filter_constraints(constraints) # If no constraints, use ECOS. if len(constraints) == 0: return s.ECOS # If mixed integer constraints, use ECOS_BB. elif constr_map[s.BOOL] or constr_map[s.INT]: return s.ECOS_BB # If SDP, defaults to CVXOPT. elif constr_map[s.SDP]: return s.CVXOPT # Otherwise use ECOS. else: return s.ECOS
def choose_solver(constraints): """Determines the appropriate solver. Parameters ---------- constraints: list The list of canonicalized constraints. Returns ------- str The solver that will be used. """ constr_map = SymData.filter_constraints(constraints) # If no constraints, use ECOS. if len(constraints) == 0: return s.ECOS # If mixed integer constraints, use ECOS_BB. elif constr_map[s.BOOL] or constr_map[s.INT]: return s.ECOS_BB # If SDP or EXP, defaults to CVXOPT. elif constr_map[s.SDP] or constr_map[s.EXP]: return s.CVXOPT # Otherwise use ECOS. else: return s.ECOS
def __init__(self, cvx_problem): objective, constraints = cvx_problem.canonicalize() self.sym_data = SymData(objective, constraints, SOLVERS[s.SCS]) # sort variables by offset self.var_ids = [ var_id for var_id, var_offset in sorted( self.sym_data.var_offsets.items(), key=lambda var_id, var_offset: var_offset) ] self.constraints = (self.sym_data.constr_map[s.EQ] + self.sym_data.constr_map[s.LEQ]) self.A_exprs, self.b = get_constraint_tensors(self.constraints) self.c = get_objective_tensor(self.var_ids, self.sym_data)
def validate_solver(self, constraints): """Raises an exception if the solver cannot solve the problem. Parameters ---------- constraints: list The list of canonicalized constraints. """ constr_map = SymData.filter_constraints(constraints) if (constr_map[s.SDP] and not self.sdp_capable()) or \ (constr_map[s.EXP] and not self.exp_capable()) or \ (len(constraints) == 0 and self.name() == s.SCS): raise SolverError( "The solver %s cannot solve the problem." % self.name() )
def __init__(self, objective, constraints, vars, params, solver=None): if vars == []: raise TypeError("Problem has no variables.") if solver == None: solver = 'ecos' elif not (solver in SOLVER_INTFS.keys): raise TypeError("Unknown solver %s." % str(solver)) self.solver = SOLVER_INTFS[solver]() self.objective = objective self.constraints = constraints self.sym_data = SymData(self.objective, self.constraints, self.solver.CVXPY_SOLVER) self.named_vars = self.get_named_vars(vars) self.params = self.get_named_params(params) # TODO rm params, so all params hanlded by the param_handler: self.template_vars = {'named_vars' : self.named_vars, 'params' : self.params, 'cprint_var' : cprint_var}
def get_sym_data(self, objective, constraints, cached_data): """Returns the symbolic data for the problem. Parameters ---------- objective : LinOp The canonicalized objective. constraints : list The list of canonicalized constraints. cached_data : dict A map of solver name to cached problem data. Returns ------- SymData The symbolic data for the problem. """ prob_data = cached_data[self.name()] if prob_data.sym_data is None: prob_data.sym_data = SymData(objective, constraints, self) return prob_data.sym_data
def validate_solver(self, constraints): """Raises an exception if the solver cannot solve the problem. Parameters ---------- constraints: list The list of canonicalized constraints. """ # Check the solver is installed. if not self.is_installed(): raise SolverError("The solver %s is not installed." % self.name()) # Check the solver can solve the problem. constr_map = SymData.filter_constraints(constraints) if ((constr_map[s.BOOL] or constr_map[s.INT]) \ and not self.MIP_CAPABLE) or \ (constr_map[s.SDP] and not self.SDP_CAPABLE) or \ (constr_map[s.EXP] and not self.EXP_CAPABLE) or \ (constr_map[s.SOC] and not self.SOCP_CAPABLE) or \ (len(constraints) == 0 and self.name() in [s.SCS, s.GLPK]): raise SolverError("The solver %s cannot solve the problem." % self.name())
def test_consistency(self): """Test that variables and constraints keep a consistent order. """ import itertools num_solves = 4 vars_lists = [] ineqs_lists = [] var_ids_order_created = [] for k in range(num_solves): sum = 0 constraints = [] var_ids = [] for i in range(100): var = Variable(name=str(i)) var_ids.append(var.id) sum += var constraints.append(var >= i) var_ids_order_created.append(var_ids) obj = Minimize(sum) p = Problem(obj, constraints) objective, constraints = p.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[s.ECOS]) # Sort by offset. vars_ = sorted(sym_data.var_offsets.items(), key=lambda key_val: key_val[1]) vars_ = [var_id for (var_id, offset) in vars_] vars_lists.append(vars_) ineqs_lists.append(sym_data.constr_map[s.LEQ]) # Verify order of variables is consistent. for i in range(num_solves): self.assertEqual(var_ids_order_created[i], vars_lists[i]) for i in range(num_solves): for idx, constr in enumerate(ineqs_lists[i]): var_id, _ = lu.get_expr_vars(constr.expr)[0] self.assertEqual(var_ids_order_created[i][idx], var_id)
def validate_solver(self, constraints): """Raises an exception if the solver cannot solve the problem. Parameters ---------- constraints: list The list of canonicalized constraints. """ # Check the solver is installed. if not self.is_installed(): raise SolverError("The solver %s is not installed." % self.name()) # Check the solver can solve the problem. constr_map = SymData.filter_constraints(constraints) if ((constr_map[s.BOOL] or constr_map[s.INT]) \ and not self.MIP_CAPABLE) or \ (constr_map[s.SDP] and not self.SDP_CAPABLE) or \ (constr_map[s.EXP] and not self.EXP_CAPABLE) or \ (constr_map[s.SOC] and not self.SOCP_CAPABLE) or \ (len(constraints) == 0 and self.name() in [s.SCS, s.GLPK]): raise SolverError( "The solver %s cannot solve the problem." % self.name() )
def validate_solver(self, constraints): """Raises an exception if the solver cannot solve the problem. Parameters ---------- constraints: list The list of canonicalized constraints. """ # Check the solver is installed. if not self.is_installed(): raise SolverError("The solver %s is not installed." % self.name()) # Check the solver can solve the problem. constr_map = SymData.filter_constraints(constraints) if (constr_map[s.BOOL] or constr_map[s.INT]) and not self.MIP_CAPABLE: self._reject_problem("it cannot solve mixed-integer problems") elif constr_map[s.SDP] and not self.SDP_CAPABLE: self._reject_problem("it cannot solve semidefinite problems") elif constr_map[s.EXP] and not self.EXP_CAPABLE: self._reject_problem("it cannot solve exponential cone problems") elif constr_map[s.SOC] and not self.SOCP_CAPABLE: self._reject_problem("it cannot solve second-order cone problems") elif len(constraints) == 0 and self.name() in (s.SCS, s.GLPK): self._reject_problem("it cannot solve unconstrained problems")
def test(self): objective, constraints = self.canonicalize() sym_data = SymData(objective, constraints, SOLVERS[s.ECOS]) return (len(sym_data.constr_map[s.EQ]), len(sym_data.constr_map[s.LEQ]))