# Object Oriented Convex Optimization¶

CVXPY enables an object-oriented approach to constructing optimization problems. An object-oriented approach is simpler and more flexible than the traditional method of constructing problems by embedding information in matrices.

Consider the max-flow problem with `N`

nodes and `E`

edges. We can
define the problem explicitly by constructing an `N`

by `E`

incidence matrix `A`

. `A[i, j]`

is +1 if edge `j`

enters node
`i`

, -1 if edge `j`

leaves node `i`

, and 0 otherwise. The source
and sink are the last two edges. The problem becomes

```
# A is the incidence matrix.
# c is a vector of edge capacities.
flows = Variable(E-2)
source = Variable()
sink = Variable()
p = Problem(Maximize(source),
[A*hstack([flows,source,sink]) == 0,
0 <= flows,
flows <= c])
```

The more natural way to frame the max-flow problem is not in terms of
incidence matrices, however, but in terms of the properties of edges and
nodes. We can write an `Edge`

class to capture these properties.

```
class Edge(object):
""" An undirected, capacity limited edge. """
def __init__(self, capacity):
self.capacity = capacity
self.flow = Variable()
# Connects two nodes via the edge.
def connect(self, in_node, out_node):
in_node.edge_flows.append(-self.flow)
out_node.edge_flows.append(self.flow)
# Returns the edge's internal constraints.
def constraints(self):
return [abs(self.flow) <= self.capacity]
```

The `Edge`

class exposes the flow into and out of the edge. The
capacity constraint is stored locally in the `Edge`

object. The graph
structure is also stored locally, by calling
`edge.connect(node1, node2)`

for each edge.

We also define a `Node`

class:

```
class Node(object):
""" A node with accumulation. """
def __init__(self, accumulation=0):
self.accumulation = accumulation
self.edge_flows = []
# Returns the node's internal constraints.
def constraints(self):
return [sum(f for f in self.edge_flows) == self.accumulation]
```

Nodes have a target amount of flow to accumulate. Sources and sinks are Nodes with a variable as their accumulation target.

Suppose `nodes`

is a list of all the nodes, `edges`

is a list of all
the edges, and `sink`

is the sink node. The problem becomes:

```
constraints = []
for obj in nodes + edges:
constraints += obj.constraints()
prob = Problem(Maximize(sink.accumulation), constraints)
```

Note that the problem has been reframed from maximizing the flow along
the source edge to maximizing the accumulation at the sink node. We
could easily extend the `Edge`

and `Node`

class to model an
electrical grid. Sink nodes would be consumers. Source nodes would be
power stations, which generate electricity at a cost. A node could be
both a source and a sink, which would represent energy storage
facilities or a consumer who contributes to the grid. We could add
energy loss along edges to more accurately model transmission lines. The
entire grid construct could be embedded in a time series model.

To see the object-oriented approach applied to more complex flow
problems, look in the `cvxpy/examples/flows/`

directory.