made AffExpression a subclass of expression

Author: Steven Diamond

cvxpy/atoms/affine/transpose.py

@@ -21,17 +21,22 @@
 from ... import utilities as u
 from ...utilities import bool_mat_utils as bu
 from ...expressions.variables import Variable
-from ...constraints.affine import AffEqConstraint
+from ...expressions.affine import AffExpression
+import copy
 
 class transpose(AffAtom):
     """ Matrix transpose. """
+    # The string representation of the atom.
+    def name(self):
+        return "%s.T" % self.args[0]
+
     # Returns the transpose of the given value.
     @AffAtom.numpy_numeric
     def numeric(self, values):
         return values[0].T
 
     # Transposes shape, sign, and curvature.
-    def set_context(self):
+    def _dcp_attr(self):
         rows,cols = self.args[0].size
         shape = u.Shape(cols, rows)
 
@@ -41,18 +46,23 @@ def set_context(self):
         conc_mat = bu.transpose(self.args[0].curvature.conc_mat)
         constant = self.args[0].curvature.constant
 
-        self._context = u.Context(u.Sign(neg_mat, pos_mat),
-                                  u.Curvature(cvx_mat, conc_mat, constant), 
-                                  shape)
+        return u.DCPAttr(u.Sign(neg_mat, pos_mat),
+                         u.Curvature(cvx_mat, conc_mat, constant), 
+                         shape)
 
     # Create a new variable equal to the argument transposed.
-    @staticmethod
-    def graph_implementation(var_args, size):
-        X = Variable(size[1], size[0])
-        obj = X.T.canonical_form()[0]
-        return (obj, [AffEqConstraint(X, var_args[0])])
-
-    # Index the original argument as if it were the transpose,
-    # then return the transpose.
-    def index_object(self, key):
-        return transpose(self.args[0][key[1], key[0]])
+    def graph_implementation(self, arg_objs):
+        X = Variable(self.size[1], self.size[0])
+        # Create a coefficients dict for the transposed variable.
+        # Each row in each block selects the appropriate elements
+        # from the vectorized X.
+        var_blocks = X.coefficients()[X]
+        transpose_coeffs = X.init_coefficients(self.size[0], self.size[1])
+        transpose_blocks = transpose_coeffs[X]
+        for k in xrange(self.size[0]):
+            for row in xrange(self.size[1]):
+                transpose_blocks[row][k,:] = var_blocks[k][row,:]
+        transpose_coeffs[X] = transpose_blocks
+        # No dcp_attr given because none needed.
+        obj = AffExpression(transpose_coeffs, None)
+        return (obj, [X == arg_objs[0]])

cvxpy/atoms/affine/vstack.py

@@ -68,7 +68,7 @@ def get_sign_curv(self):
     def set_context(self):
         shape = self.get_shape()
         sign,curvature = self.get_sign_curv()
-        self._context = u.Context(sign, curvature, shape)
+        self._context = u.DCPAttr(sign, curvature, shape)
 
     @staticmethod
     def graph_implementation(var_args, size):

cvxpy/atoms/atom.py

@@ -20,11 +20,9 @@
 from .. import settings as s
 from .. import utilities as u
 from .. import interface as intf
+from ..expressions.constants import Constant
 from ..expressions.variables import Variable
 from ..expressions.expression import Expression
-from ..expressions.affine import AffExpression
-from ..constraints.affine import AffEqConstraint, AffLeqConstraint
-from constant_atom import ConstantAtom
 import abc
 
 class Atom(Expression):
@@ -40,24 +38,22 @@ def __init__(self, *args):
         # Convert raw values to Constants.
         self.args = map(Expression.cast_to_const, args)
         self.subexpressions = self.args
-        # Initialize context.
-        self.set_context()
         super(Atom, self).__init__()
 
     # Returns the string representation of the function call.
     def name(self):
         return "%s(%s)" % (self.__class__.__name__, 
                            ", ".join([arg.name() for arg in self.args]))
 
-    # Sets signed curvature based on the arguments' signed curvatures.
-    def set_context(self):
+    # Determines the curvature, sign, and shape from the arguments.
+    def _dcp_attr(self):
         # Initialize _shape. Raises an error for invalid argument sizes.
-        self.set_shape()
+        shape = self.shape_from_args()
         sign = self.sign_from_args()
         curvature = Atom.dcp_curvature(self.base_curvature(), 
                                        self.args, 
                                        self.monotonicity())
-        self._context = u.Context(sign, curvature, self._shape)
+        self._context = u.DCPAttr(sign, curvature, self._shape)
 
     # Returns argument curvatures as a list.
     def argument_curvatures(self):
@@ -91,30 +87,24 @@ def dcp_curvature(curvature, args, monotonicities):
     def canonicalize(self):
         # Constant atoms are treated as a leaf.
         if self.curvature.is_constant():
-            obj = AffExpression({s.CONSTANT: self}, self.shape)
-            return (obj, [])
-        # Non-constant atoms are expanded into an affine objective and constraints.
+            return Constant(self.value).canonicalize()
         else:
-            var_args = []
-            final_constraints = []
+            arg_objs = []
+            constraints = []
             for arg in self.args:
-                # canonicalize arguments.
-                obj,constraints = arg.canonical_form()
-                var_args.append(obj)
-                final_constraints += constraints
-            graph_var,graph_constr = self.graph_implementation(var_args, self.size)
-            obj = u.Affine.cast_as_affine(graph_var)
-            return (obj,final_constraints + graph_constr)
+                obj,constr = arg.canonicalize()
+                arg_objs.append(obj)
+                constraints += constr
+            graph_obj,graph_constr = self.graph_implementation(arg_objs)
+            return (graph_obj, constraints + graph_constr)
 
-    # Returns a variable and set of affine/SOC 
+    # Returns an affine expression and list of 
     # constraints equivalent to the atom.
-    # var_args - a list of single variable arguments.
-    # size - the dimensions of the variable to return.
+    # arg_objs - the canonical objectives of the arguments.
     @abc.abstractmethod
-    def graph_implementation(var_args, size):
+    def graph_implementation(self, arg_objs):
         return NotImplemented
 
-
     # Wraps an atom's numeric function that requires numpy ndarrays as input.
     # Ensures both inputs and outputs are the correct matrix types.
     @staticmethod

cvxpy/atoms/constant_atom.py

@@ -18,7 +18,6 @@
 """
 
 from leq_constraint import LeqConstraint
-from affine import AffEqConstraint, AffLeqConstraint
 
 class EqConstraint(LeqConstraint):
     OP_NAME = "=="
@@ -29,7 +28,5 @@ def is_dcp(self):
     # TODO expanding equality constraints.
     # Verify doesn't affect dual variables.
     def canonicalize(self):
-        self._expr = (self.lh_exp - self.rh_exp)
         obj,constr = self._expr.canonical_form()
-        dual_holder = AffEqConstraint(obj, 0, self)
-        return (None, [dual_holder] + constr)
+        return (None, [obj == 0] + constr)

cvxpy/constraints/eq_constraint.py

@@ -19,15 +19,13 @@
 
 from .. import interface as intf
 from .. import utilities as u
-from ..expressions import types
-from affine import AffEqConstraint, AffLeqConstraint
 
-class LeqConstraint(u.Canonicalizable):
+class LeqConstraint(object):
     OP_NAME = "<="
     def __init__(self, lh_exp, rh_exp):
         self.lh_exp = lh_exp
         self.rh_exp = rh_exp
-        super(LeqConstraint, self).__init__()
+        self._expr = (self.lh_exp - self.rh_exp)
 
     def name(self):
         return ' '.join([self.lh_exp.name(), 
@@ -52,7 +50,15 @@ def is_dcp(self):
 
     # Replace inequality with an equality with slack.
     def canonicalize(self):
-        self._expr = (self.lh_exp - self.rh_exp)
         obj,constr = self._expr.canonical_form()
-        dual_holder = AffLeqConstraint(obj, 0, self)
-        return (None, [dual_holder] + constr)
+        return (None, [obj <= 0] + constr)
+
+    def variables(self):
+        return self._expr.variables()
+
+    def coefficients(self):
+        return self._expr.coefficients()
+
+    # Save the value of the dual variable for the constraint's parent.
+    def save_value(self, value):
+        self._parent.dual_value = value

cvxpy/constraints/leq_constraint.py

@@ -19,7 +19,6 @@
 
 from .. import interface as intf
 from .. import utilities as u
-from affine import AffLeqConstraint
 
 class SOC(object):
     """ 
@@ -35,8 +34,7 @@ def __init__(self, t, x):
 
     # Formats SOC constraints for the solver.
     def format(self):
-        return [AffLeqConstraint(-self.t, 0), 
-                AffLeqConstraint(-self.x, 0)]
+        return [-self.t <= 0, -self.x <= 0]
 
     # The dimensions of the second-order cone.
     @property

cvxpy/constraints/second_order.py

@@ -20,7 +20,6 @@
 from .. import interface as intf
 from .. import utilities as u
 from ..expressions.variables import Variable
-from affine import AffEqConstraint, AffLeqConstraint
 
 class SDP(object):
     """
@@ -36,7 +35,7 @@ def __init__(self, A):
 
     # Formats SDP constraints for the solver.
     def format(self):
-        return [AffLeqConstraint(-self.A, 0)]
+        return [-self.A <= 0]
 
     # The dimensions of the semi-definite cone.
     @property