refactoring matrix data refactor

Author: Steven Diamond

cvxpy/lin_ops/lin_utils.py

@@ -489,3 +489,24 @@ def get_expr_vars(operator):
         for arg in operator.args:
             vars_ += get_expr_vars(arg)
         return vars_
+
+def get_expr_params(operator):
+    """Get a list of the parameters in the operator.
+
+    Parameters
+    ----------
+    operator : LinOp
+        The operator to extract the parameters from.
+
+    Returns
+    -------
+    list
+        A list of parameter objects.
+    """
+    if operator.type is lo.PARAM:
+        return [operator.data.parameters()]
+    else:
+        vars_ = []
+        for arg in operator.args:
+            vars_ += get_expr_params(arg)
+        return vars_

cvxpy/problems/problem_data.py cvxpy/problems/matrix_data.py

@@ -17,12 +17,14 @@
 along with CVXPY.  If not, see <http://www.gnu.org/licenses/>.
 """
 
+import cvxpy.interface as intf
 import cvxpy.lin_ops as lo
 import cvxpy.lin_ops.lin_utils as lu
 import cvxpy.lin_ops.lin_to_matrix as op2mat
+import scipy.sparse as sp
 
-class ProblemData(object):
-    """The data for a convex optimization problem.
+class MatrixData(object):
+    """The matrices for the conic form convex optimization problem.
 
     Attributes
     ----------
@@ -43,6 +45,7 @@ class ProblemData(object):
     vec_intf : interface
         The matrix interface to use for creating the constant vector.
     """
+
     def __init__(self, var_offsets, x_length, objective,
                  eq_constr, ineq_constr, nonlin_constr,
                  matrix_intf, vec_intf):
@@ -57,13 +60,9 @@ def __init__(self, var_offsets, x_length, objective,
         self.nonlin_constr = nonlin_constr
         self.matrix_intf = matrix_intf
         self.vec_intf = vec_intf
-        # Cache everything possible.
-        self._cache_all()
 
-    def _cache_all(self):
-        """Caches all the data possible.
-        """
-        self.c_COO, self.offset =  self._init_matrix_cache(self._dummy_constr)
+        # Cache everything possible.
+        self.c_COO, self.offset = self._init_matrix_cache(self._dummy_constr)
         self._lin_matrix(self._dummy_constr, self.c_COO,
                          self.offset, caching=True)
         # Equaliy constraints.
@@ -80,7 +79,7 @@ def get_objective(self):
         """
         c, offset = self._cache_to_matrix(self._dummy_constr, self.c_COO,
                                           self.offset)
-        offset = intf.matrix_intf.scalar_value(offset)
+        offset = self.matrix_intf.scalar_value(offset)
         return c.T, offset
 
     def get_eq_constr(self):
@@ -93,6 +92,10 @@ def get_ineq_constr(self):
         """
         return self._cache_to_matrix(self.eq_constr, self.G_COO, self.h)
 
+    def get_nonlin_constr(self):
+        """Returns the oracle function for the nonlinear constraints.
+        """
+        return self.F
 
     def _constr_matrix_size(self, constraints):
         """Returns the dimensions of the constraint matrix.
@@ -120,12 +123,12 @@ def _init_matrix_cache(self, constraints):
         -------
         ((V, I, J), array)
         """
-        rows = _constr_matrix_size(constraints)[0]
+        rows = self._constr_matrix_size(constraints)[0]
         COO = ([], [], [])
         const_vec = self.vec_intf.zeros(rows, 1)
         return (COO, const_vec)
 
-    def _lin_matrix(self, constraints, COO, const_vec, caching=False):
+    def _lin_matrix(self, constraints, coo_tup, const_vec, caching=False):
         """Computes a matrix and vector representing a list of constraints.
 
         In the matrix, each constraint is given a block of rows.
@@ -137,7 +140,7 @@ def _lin_matrix(self, constraints, COO, const_vec, caching=False):
         ----------
         constraints : list
             A list of constraints in the matrix.
-        COO : tuple
+        coo_tup : tuple
             A (V, I, J) triplet.
         const_vec : array
             The constant term.
@@ -149,23 +152,22 @@ def _lin_matrix(self, constraints, COO, const_vec, caching=False):
         tuple
             A (matrix, vector) tuple.
         """
-        V, I, J = COO
         vert_offset = 0
         for constr in constraints:
             # Process the constraint if it has a parameter and not caching
             # or it doesn't have a parameter and caching.
             if lu.get_expr_params(constr.expr) != caching:
-                self._process_constr(constr, V, I, J, const_vec, vert_offset)
+                self._process_constr(constr, coo_tup, const_vec, vert_offset)
             vert_offset += constr.size[0]*constr.size[1]
 
-    def _cache_to_matrix(self, constraints, COO, const_vec):
+    def _cache_to_matrix(self, constraints, coo_tup, const_vec):
         """Converts the cached representation of the constraints matrix.
 
         Parameters
         ----------
         constraints : list
             A list of constraints in the matrix.
-        COO : tuple
+        coo_tup : tuple
             A (V, I, J) triplet.
         const_vec : array
             The constant term.
@@ -176,36 +178,34 @@ def _cache_to_matrix(self, constraints, COO, const_vec):
         """
         rows, cols = self._constr_matrix_size(constraints)
         # Create the constraints matrix.
-        V, I, J = COO
+        V, I, J = coo_tup
         if len(V) > 0:
             matrix = sp.coo_matrix((V, (I, J)), (rows, cols))
             # Convert the constraints matrix to the correct type.
-            matrix = matrix_intf.const_to_matrix(matrix, convert_scalars=True)
+            matrix = self.matrix_intf.const_to_matrix(matrix,
+                                                      convert_scalars=True)
         else: # Empty matrix.
-            matrix = matrix_intf.zeros(rows, cols)
+            matrix = self.matrix_intf.zeros(rows, cols)
         # Convert 2D ND arrays to 1D
         if self.vec_intf is intf.DEFAULT_INTERFACE:
             const_vec = intf.from_2D_to_1D(const_vec)
         return (matrix, -const_vec)
 
-    def _process_constr(self, constr, V, I, J, const_vec, vert_offset):
+    def _process_constr(self, constr, coo_tup, const_vec, vert_offset):
         """Extract the coefficients from a constraint.
 
         Parameters
         ----------
         constr : LinConstr
             The linear constraint to process.
-        V : list
-            A list of values in the COO sparse matrix.
-        I : list
-            A list of rows in the COO sparse matrix.
-        J : list
-            A list of columns in the COO sparse matrix.
+        coo_tup : tuple
+            A (V, I, J) triplet.
         const_vec : array
             The constant vector.
         vert_offset : int
             The row offset of the constraint.
         """
+        V, I, J = coo_tup
         coeffs = op2mat.get_coefficients(constr.expr)
         for id_, block in coeffs:
             vert_start = vert_offset
@@ -255,6 +255,8 @@ def _nonlin_matrix(self):
             constr.place_x0(big_x, self.var_offsets, self.vec_intf)
 
         def F(x=None, z=None):
+            """Oracle for function value, gradient, and Hessian.
+            """
             if x is None:
                 return rows, big_x
             big_f = self.vec_intf.zeros(rows, 1)

cvxpy/problems/objective.py

@@ -67,7 +67,7 @@ def value(self):
         return self._expr.value
 
     @staticmethod
-    def _primal_to_result(result):
+    def primal_to_result(result):
         """The value of the objective given the solver primal value.
         """
         return result

cvxpy/problems/problem.py

@@ -24,23 +24,19 @@
 from cvxpy.error import SolverError
 import cvxpy.lin_ops.lin_utils as lu
 import cvxpy.lin_ops as lo
-import cvxpy.lin_ops.tree_mat as tree_mat
+import cvxpy.lin_ops.lin_to_matrix as op2mat
 from cvxpy.constraints import (EqConstraint, LeqConstraint,
-SOC, SOC_Elemwise, SDP, ExpCone)
+SOC, SDP, ExpCone)
 from cvxpy.problems.objective import Minimize, Maximize
 from cvxpy.problems.kktsolver import get_kktsolver
-import cvxpy.problems.iterative as iterative
 from cvxpy.problems.problem_data import ProblemData
 
 from collections import OrderedDict
 import warnings
-import itertools
-import numbers
 import cvxopt
 import cvxopt.solvers
 import ecos
 import numpy as np
-import scipy.sparse as sp
 
 # Attempt to import SCS.
 try:
@@ -69,16 +65,29 @@ class Problem(u.Canonical):
 
     def __init__(self, objective, constraints=None):
         if constraints is None:
-            constraints = []
+            constraints = ()
         # Check that objective is Minimize or Maximize.
         if not isinstance(objective, (Minimize, Maximize)):
             raise TypeError("Problem objective must be Minimize or Maximize.")
-        self.objective = objective
-        self.constraints = constraints
+        # Constraints and objective are immutable.
+        self._objective = objective
+        self._constraints = tuple(constraints)
         self._value = None
         self._status = None
         self._cached_data = {}
 
+    @property
+    def objective(self):
+        """Getter for objective.
+        """
+        return self._objective
+
+    @property
+    def constraints(self):
+        """Getter for constraints tuple.
+        """
+        return self._constraints
+
     @property
     def value(self):
         """The value from the last time the problem was solved.
@@ -104,7 +113,8 @@ def is_dcp(self):
         """
         return all(exp.is_dcp() for exp in self.constraints + [self.objective])
 
-    def _filter_constraints(self, constraints):
+    @staticmethod
+    def _filter_constraints(constraints):
         """Separate the constraints by type.
 
         Parameters
@@ -156,7 +166,8 @@ def canonicalize(self):
 
         return (obj, constr_map)
 
-    def _presolve(self, objective, constr_map):
+    @staticmethod
+    def _presolve(objective, constr_map):
         """Eliminates unnecessary constraints and short circuits the solver
         if possible.
 
@@ -192,10 +203,11 @@ def _presolve(self, objective, constr_map):
                     coeff = op2mat.get_constant_coeff(constr.expr)
                     sign = intf.sign(coeff)
                     # For equality constraint, coeff must be zero.
-                    # For inequality (i.e. <= 0) constraint, coeff must be negative.
+                    # For inequality (i.e. <= 0) constraint,
+                    # coeff must be negative.
                     if key is s.EQ and not sign.is_zero() or \
-                       key is s.LEQ and not sign.is_negative():
-                       return s.INFEASIBLE
+                        key is s.LEQ and not sign.is_negative():
+                        return s.INFEASIBLE
                 else:
                     new_constraints.append(constr)
             constr_map[key] = new_constraints
@@ -355,22 +367,16 @@ def get_problem_data(self, solver):
         # Raise an error if the solver cannot handle the problem.
         self._validate_solver(constr_map, solver)
         dims = self._format_for_solver(constr_map, solver)
+        # TODO factor out.
         all_ineq = constr_map[s.EQ] + constr_map[s.LEQ]
+        # CVXOPT can have variables that only live in NonLinearConstraints.
+        nonlinear = constr_map[s.EXP] if solver == s.CVXOPT else []
         var_offsets, var_sizes, x_length = self._get_var_offsets(objective,
-                                                                 all_ineq)
-
-        if solver == s.ECOS and not (constr_map[s.SDP] or constr_map[s.EXP]):
-            args, offset = self._ecos_problem_data(objective, constr_map, dims,
-                                                   var_offsets, x_length)
-        elif solver == s.CVXOPT and not constr_map[s.EXP]:
-            args, offset = self._cvxopt_problem_data(objective, constr_map, dims,
-                                                     var_offsets, x_length)
-        elif solver == s.SCS:
-            args, offset = self._scs_problem_data(objective, constr_map, dims,
-                                                  var_offsets, x_length)
-        else:
-            raise SolverError("Cannot return problem data for the solver %s." % solver)
-        return args
+                                                                 all_ineq,
+                                                                 nonlinear)
+        return SOLVERS[solver].get_problem_data(self._cached_data, objective,
+                                                constr_map, dims,
+                                                var_offsets, x_length)
 
     def _solve(self, solver=None, ignore_dcp=False, verbose=False, **kwargs):
         """Solves a DCP compliant optimization problem.
@@ -425,7 +431,8 @@ def _solve(self, solver=None, ignore_dcp=False, verbose=False, **kwargs):
                                                                      all_ineq,
                                                                      nonlinear)
             if solver in s.SOLVERS:
-                result = solve_methods[solver](objective, constr_map, dims,
+                result = SOLVERS[solver].solve(self._cached_data, objective,
+                                               constr_map, dims,
                                                var_offsets, x_length,
                                                verbose, kwargs)
             else:
@@ -453,7 +460,7 @@ def _ecos_problem_data(self, objective, constr_map, dims,
 
         Parameters
         ----------
-            objective: Expression
+            objective: LinOp
                 The canonicalized objective.
             constr_map: dict
                 A dict of the canonicalized constraints.
@@ -520,7 +527,7 @@ def _ecos_solve(self, objective, constr_map, dims,
         status = s.SOLVER_STATUS[s.ECOS][results['info']['exitFlag']]
         if status in s.SOLUTION_PRESENT:
             primal_val = results['info']['pcost']
-            value = self.objective._primal_to_result(
+            value = self.objective.primal_to_result(
                           primal_val - obj_offset)
             return (status, value,
                     results['x'], results['y'], results['z'])
@@ -602,7 +609,7 @@ def _cvxopt_solve(self, objective, constr_map, dims,
         """
         prob_data = self._cvxopt_problem_data(objective, constr_map, dims,
                                               var_offsets, x_length)
-        c, G, h, dims, A, b, F = prob_data[0]
+        c, G, h, dims, A, b = prob_data[0]
         obj_offset = prob_data[1]
         # Save original cvxopt solver options.
         old_options = cvxopt.solvers.options
@@ -632,14 +639,14 @@ def _cvxopt_solve(self, objective, constr_map, dims,
                                                 kktsolver=kktsolver)
             status = s.SOLVER_STATUS[s.CVXOPT][results['status']]
         # Catch exceptions in CVXOPT and convert them to solver errors.
-        except ValueError as e:
+        except ValueError:
             status = s.SOLVER_ERROR
 
         # Restore original cvxopt solver options.
         cvxopt.solvers.options = old_options
         if status in s.SOLUTION_PRESENT:
             primal_val = results['primal objective']
-            value = self.objective._primal_to_result(
+            value = self.objective.primal_to_result(
                           primal_val - obj_offset)
             if constr_map[s.EXP]:
                 ineq_dual = results['zl']
@@ -746,11 +753,12 @@ def _handle_no_solution(self, status):
             constr.save_value(None)
         # Set the problem value.
         if status in [s.INFEASIBLE, s.INFEASIBLE_INACCURATE]:
-            self._value = self.objective._primal_to_result(np.inf)
+            self._value = self.objective.primal_to_result(np.inf)
         elif status in [s.UNBOUNDED, s.UNBOUNDED_INACCURATE]:
-            self._value = self.objective._primal_to_result(-np.inf)
+            self._value = self.objective.primal_to_result(-np.inf)
 
-    def _get_var_offsets(self, objective, constraints, nonlinear=None):
+    @staticmethod
+    def _get_var_offsets(objective, constraints, nonlinear=None):
         """Maps each variable to a horizontal offset.
 
         Parameters