def test_zero_capacity_edges(self):
        """Address issue raised in ticket #617 by arv."""
        G = nx.DiGraph()
        G.add_edges_from([(1, 2, {'capacity': 1, 'weight': 1}),
                          (1, 5, {'capacity': 1, 'weight': 1}),
                          (2, 3, {'capacity': 0, 'weight': 1}),
                          (2, 5, {'capacity': 1, 'weight': 1}),
                          (5, 3, {'capacity': 2, 'weight': 1}),
                          (5, 4, {'capacity': 0, 'weight': 1}),
                          (3, 4, {'capacity': 2, 'weight': 1})])
        G.nodes[1]['demand'] = -1
        G.nodes[2]['demand'] = -1
        G.nodes[4]['demand'] = 2

        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 0, 5: 1},
                2: {3: 0, 5: 1},
                3: {4: 2},
                4: {},
                5: {3: 2, 4: 0}}
        assert_equal(flowCost, 6)
        assert_equal(nx.min_cost_flow_cost(G), 6)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 6)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 6)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 6)

    def test_digon(self):
        """Check if digons are handled properly. Taken from ticket
        #618 by arv."""
        nodes = [(1, {}),
                 (2, {'demand': -4}),
                 (3, {'demand': 4}),
                 ]
        edges = [(1, 2, {'capacity': 3, 'weight': 600000}),
                 (2, 1, {'capacity': 2, 'weight': 0}),
                 (2, 3, {'capacity': 5, 'weight': 714285}),
                 (3, 2, {'capacity': 2, 'weight': 0}),
                 ]
        G = nx.DiGraph(edges)
        G.add_nodes_from(nodes)
        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 0},
                2: {1: 0, 3: 4},
                3: {2: 0}}
        assert_equal(flowCost, 2857140)
        assert_equal(nx.min_cost_flow_cost(G), 2857140)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 2857140)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 2857140)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 2857140)

    def test_max_flow_min_cost(self):
        G = nx.DiGraph()
        G.add_edge('s', 'a', bandwidth=6)
        G.add_edge('s', 'c', bandwidth=10, cost=10)
        G.add_edge('a', 'b', cost=6)
        G.add_edge('b', 'd', bandwidth=8, cost=7)
        G.add_edge('c', 'd', cost=10)
        G.add_edge('d', 't', bandwidth=5, cost=5)
        soln = {'s': {'a': 5, 'c': 0},
                'a': {'b': 5},
                'b': {'d': 5},
                'c': {'d': 0},
                'd': {'t': 5},
                't': {}}
        flow = nx.max_flow_min_cost(G, 's', 't', capacity='bandwidth',
                                    weight='cost')
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)

        G.add_edge('t', 's', cost=-100)
        flowCost, flow = nx.capacity_scaling(G, capacity='bandwidth',
                                             weight='cost')
        G.remove_edge('t', 's')
        assert_equal(flowCost, -410)
        assert_equal(flow['t']['s'], 5)
        del flow['t']['s']
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow, weight='cost'), 90)

    def test_digraph1(self):
        # From Bradley, S. P., Hax, A. C. and Magnanti, T. L. Applied
        # Mathematical Programming. Addison-Wesley, 1977.
        G = nx.DiGraph()
        G.add_node(1, demand=-20)
        G.add_node(4, demand=5)
        G.add_node(5, demand=15)
        G.add_edges_from([(1, 2, {'capacity': 15, 'weight': 4}),
                          (1, 3, {'capacity': 8, 'weight': 4}),
                          (2, 3, {'weight': 2}),
                          (2, 4, {'capacity': 4, 'weight': 2}),
                          (2, 5, {'capacity': 10, 'weight': 6}),
                          (3, 4, {'capacity': 15, 'weight': 1}),
                          (3, 5, {'capacity': 5, 'weight': 3}),
                          (4, 5, {'weight': 2}),
                          (5, 3, {'capacity': 4, 'weight': 1})])
        flowCost, H = nx.network_simplex(G)
        soln = {1: {2: 12, 3: 8},
                2: {3: 8, 4: 4, 5: 0},
                3: {4: 11, 5: 5},
                4: {5: 10},
                5: {3: 0}}
        assert_equal(flowCost, 150)
        assert_equal(nx.min_cost_flow_cost(G), 150)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 150)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 150)
        assert_equal(H, soln)
        assert_equal(nx.cost_of_flow(G, H), 150)

 def test_large(self):
     fname = os.path.join(os.path.dirname(__file__), 'netgen-2.gpickle.bz2')
     G = nx.read_gpickle(fname)
     flowCost, flowDict = nx.network_simplex(G)
     assert_equal(6749969302, flowCost)
     assert_equal(6749969302, nx.cost_of_flow(G, flowDict))
     flowCost, flowDict = nx.capacity_scaling(G)
     assert_equal(6749969302, flowCost)
     assert_equal(6749969302, nx.cost_of_flow(G, flowDict))

def optimal_procurement(supply_cost, x_max, demand_quantity, holding_cost, backlogging_cost, xh_0=0, xh_n=0):
    """Calculates optimal procurement planning.

    Arguments:
    supply_cost -- Supply cost at each time period
    x_max -- Maximum supply quantity at each time period.
    demand_quantity -- Demand quantity at each time period
    holding_cost -- Holding cost.
    backlogging_cost -- Backlogging cost.
    xh_0 -- Initial inventory.
    x_hn -- Final inventory target.
    """

    G = nx.DiGraph()
    n = len(supply_cost)
    for t in range(n):
        G.add_edge("source", t, {'capacity': x_max[t], 'weight': supply_cost[t]})
        G.add_edge(t, "sink", {'capacity': demand_quantity[t], 'weight': 0})
        G.add_edge(t, t + 1, {'capacity': np.inf, 'weight': holding_cost})
        G.add_edge(t + 1, t, {'capacity': np.inf, 'weight': backlogging_cost})

    G.add_edge("source", -1, {'capacity': xh_0, 'weight': 0})
    G.add_edge(-1, 0, {'capacity': xh_0, 'weight': 0})

    G.add_edge(n, "sink", {'capacity': xh_n, 'weight': 0})

    mincost_flow = nx.max_flow_min_cost(G, "source", "sink")
    cost = nx.cost_of_flow(G, mincost_flow)
    return cost, np.array([mincost_flow['source'][t] for t in range(n)])

    def test_transshipment(self):
        G = nx.DiGraph()
        G.add_node('a', demand=1)
        G.add_node('b', demand=-2)
        G.add_node('c', demand=-2)
        G.add_node('d', demand=3)
        G.add_node('e', demand=-4)
        G.add_node('f', demand=-4)
        G.add_node('g', demand=3)
        G.add_node('h', demand=2)
        G.add_node('r', demand=3)
        G.add_edge('a', 'c', weight=3)
        G.add_edge('r', 'a', weight=2)
        G.add_edge('b', 'a', weight=9)
        G.add_edge('r', 'c', weight=0)
        G.add_edge('b', 'r', weight=-6)
        G.add_edge('c', 'd', weight=5)
        G.add_edge('e', 'r', weight=4)
        G.add_edge('e', 'f', weight=3)
        G.add_edge('h', 'b', weight=4)
        G.add_edge('f', 'd', weight=7)
        G.add_edge('f', 'h', weight=12)
        G.add_edge('g', 'd', weight=12)
        G.add_edge('f', 'g', weight=-1)
        G.add_edge('h', 'g', weight=-10)
        flowCost, H = nx.network_simplex(G)
        soln = {'a': {'c': 0},
                'b': {'a': 0, 'r': 2},
                'c': {'d': 3},
                'd': {},
                'e': {'r': 3, 'f': 1},
                'f': {'d': 0, 'g': 3, 'h': 2},
                'g': {'d': 0},
                'h': {'b': 0, 'g': 0},
                'r': {'a': 1, 'c': 1}}
        assert_equal(flowCost, 41)
        assert_equal(nx.min_cost_flow_cost(G), 41)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 41)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 41)
        assert_equal(nx.cost_of_flow(G, H), 41)
        assert_equal(H, soln)

    def test_digraph3(self):
        """Combinatorial Optimization: Algorithms and Complexity,
        Papadimitriou Steiglitz at page 140 has an example, 7.1, but that
        admits multiple solutions, so I alter it a bit. From ticket #430
        by mfrasca."""

        G = nx.DiGraph()
        G.add_edge('s', 'a')
        G['s']['a'].update({0: 2, 1: 4})
        G.add_edge('s', 'b')
        G['s']['b'].update({0: 2, 1: 1})
        G.add_edge('a', 'b')
        G['a']['b'].update({0: 5, 1: 2})
        G.add_edge('a', 't')
        G['a']['t'].update({0: 1, 1: 5})
        G.add_edge('b', 'a')
        G['b']['a'].update({0: 1, 1: 3})
        G.add_edge('b', 't')
        G['b']['t'].update({0: 3, 1: 2})

        "PS.ex.7.1: testing main function"
        sol = nx.max_flow_min_cost(G, 's', 't', capacity=0, weight=1)
        flow = sum(v for v in sol['s'].values())
        assert_equal(4, flow)
        assert_equal(23, nx.cost_of_flow(G, sol, weight=1))
        assert_equal(sol['s'], {'a': 2, 'b': 2})
        assert_equal(sol['a'], {'b': 1, 't': 1})
        assert_equal(sol['b'], {'a': 0, 't': 3})
        assert_equal(sol['t'], {})

        G.add_edge('t', 's')
        G['t']['s'].update({1: -100})
        flowCost, sol = nx.capacity_scaling(G, capacity=0, weight=1)
        G.remove_edge('t', 's')
        flow = sum(v for v in sol['s'].values())
        assert_equal(4, flow)
        assert_equal(sol['t']['s'], 4)
        assert_equal(flowCost, -377)
        del sol['t']['s']
        assert_equal(sol['s'], {'a': 2, 'b': 2})
        assert_equal(sol['a'], {'b': 1, 't': 1})
        assert_equal(sol['b'], {'a': 0, 't': 3})
        assert_equal(sol['t'], {})
        assert_equal(nx.cost_of_flow(G, sol, weight=1), 23)

def pr345():
    G = nx.DiGraph()
    n = len(data)
    for i in range(n): 
        G.add_edge('s', 'A'+str(i), weight=0, capacity=1)
        G.add_edge('B'+str(i), 't', weight=0, capacity=1)
    for i in range(n):
        for j in range(n):
            G.add_edge('A'+str(i), 'B'+str(j), weight=-data[i][j], capacity=1)
    flow = nx.max_flow_min_cost(G, 's', 't')
    return -nx.cost_of_flow(G, flow)

    def test_finite_capacity_neg_digon(self):
        """The digon should receive the maximum amount of flow it can handle.
        Taken from ticket #749 by @chuongdo."""
        G = nx.DiGraph()
        G.add_edge('a', 'b', capacity=1, weight=-1)
        G.add_edge('b', 'a', capacity=1, weight=-1)
        min_cost = -2
        assert_equal(nx.min_cost_flow_cost(G), min_cost)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, -2)
        assert_equal(H, {'a': {'b': 1}, 'b': {'a': 1}})
        assert_equal(nx.cost_of_flow(G, H), -2)

    def test_simple_digraph(self):
        G = nx.DiGraph()
        G.add_node('a', demand=-5)
        G.add_node('d', demand=5)
        G.add_edge('a', 'b', weight=3, capacity=4)
        G.add_edge('a', 'c', weight=6, capacity=10)
        G.add_edge('b', 'd', weight=1, capacity=9)
        G.add_edge('c', 'd', weight=2, capacity=5)
        flowCost, H = nx.network_simplex(G)
        soln = {'a': {'b': 4, 'c': 1},
                'b': {'d': 4},
                'c': {'d': 1},
                'd': {}}
        assert_equal(flowCost, 24)
        assert_equal(nx.min_cost_flow_cost(G), 24)
        assert_equal(H, soln)
        assert_equal(nx.min_cost_flow(G), soln)
        assert_equal(nx.cost_of_flow(G, H), 24)

        flowCost, H = nx.capacity_scaling(G)
        assert_equal(flowCost, 24)
        assert_equal(nx.cost_of_flow(G, H), 24)
        assert_equal(H, soln)

 def test_max_flow_min_cost(self):
     G = nx.DiGraph()
     G.add_edge('s', 'a', bandwidth = 6)
     G.add_edge('s', 'c', bandwidth = 10, cost = 10)
     G.add_edge('a', 'b', cost = 6)
     G.add_edge('b', 'd', bandwidth = 8, cost = 7)
     G.add_edge('c', 'd', cost = 10)
     G.add_edge('d', 't', bandwidth = 5, cost = 5)
     soln = {'s': {'a': 5, 'c': 0},
             'a': {'b': 5},
             'b': {'d': 5},
             'c': {'d': 0},
             'd': {'t': 5},
             't': {}}
     flow = nx.max_flow_min_cost(G, 's', 't', capacity = 'bandwidth',
                                 weight = 'cost')
     assert_equal(flow, soln)
     assert_equal(nx.cost_of_flow(G, flow, weight = 'cost'), 90)

def buildGraph(inputData):
    """

    :param inputData:
    """
    sellerArray, customerArray, costMatrix = inputData
    G = nx.Graph()
    for i in range(1, len(sellerArray) + 1):
        for j in range(1, 1 + len(customerArray)):
            G.add_edge(i, j + len(sellerArray), capacity=inf, weight=int(costMatrix[i - 1][j - 1]))
        G.add_edge(0, i, {'capacity': sellerArray[i - 1], 'weight': int(0)})
    sum = len(sellerArray) + len(customerArray) + 1
    for j in range(len(customerArray)):
        G.add_edge(len(sellerArray) + j + 1, sum, capacity=customerArray[j - 1], weight=0)
        #minCostFlow = nx.max_flow_min_cost(G)
    c1 = 25000 / len(sellerArray)
    c2 = 25000 / len(customerArray)
    pos = {0: (15000.0, -12000.0), len(sellerArray) + len(customerArray) + 1: (15000.0, 12000.0)}
    for i in range(0, len(sellerArray)):
        pos[i + 1] = (i * c1, -7500.0)
    for n in range(len(sellerArray), len(sellerArray) + len(customerArray)):
        pos[n + 1] = ((n - len(sellerArray)) * c2, 7500.0)
        colors = [d['weight'] for (u, v, d) in G.edges(data=True)]
    flow = nx.max_flow_min_cost(G, 0, len(sellerArray) + len(customerArray) + 1)
    costOfFlow = nx.cost_of_flow(G, flow)
    print("Cost: " + str(costOfFlow))
    newEdgeList = []
    for k, v in flow.items():
        for i, j in v.items():
            if G.has_edge(k, i) and j > 0:
                newEdgeList.append([k, i])

    edge_labels = {}
    for u, v, d in G.edges(data=True):
        if flow[u][v] > 0:
            edge_labels[(u, v,)] = str(flow[u][v]) + "/" + str(d['weight'])
    print(costOfFlow, flow)
    nx.draw_networkx(G, pos, edgelist=newEdgeList, node_shape='o', node_color='#A0CBE2', edge_labels=edge_labels,
                     width=1.5, alpha=1,
                     edge_cmap=P.cm.ma,
                     with_labels=True)
    nx.draw_networkx_edge_labels(G, pos, edge_labels, label_pos=0.7, font_size=8)
    P.show()

 def set_flow(self):
     try:
         self.flow = nx.max_flow_min_cost(self, self.source, self.sink)
         self.flow_cost = nx.cost_of_flow(self, self.flow)
         self.max_flow = nx.maximum_flow(self, self.source, self.sink)[0]
     except nx.NetworkXUnfeasible:
         print 'Allocation satisfying the lower bounds is not possible.'
         print 'Try reducing lower bounds.'
         sys.exit(1)
     except nx.NetworkXError:
         print "The input graph is not directed or not connected."
         print "Please check the data:"
         print "e.g. if all the choices on the level 1 list are" \
               " included in the level 2 list and same for levels 2, 3."
         sys.exit(1)
     except nx.NetworkXUnbounded:
         print "Allocation is not possible because some upper capacity" \
               "bounds at level 1 have not been set up. Please check " \
               "the data."
         sys.exit(1)

    def test_digraph2(self):
        # Example from ticket #430 from mfrasca. Original source:
        # http://www.cs.princeton.edu/courses/archive/spr03/cs226/lectures/mincost.4up.pdf, slide 11.
        G = nx.DiGraph()
        G.add_edge('s', 1, capacity=12)
        G.add_edge('s', 2, capacity=6)
        G.add_edge('s', 3, capacity=14)
        G.add_edge(1, 2, capacity=11, weight=4)
        G.add_edge(2, 3, capacity=9, weight=6)
        G.add_edge(1, 4, capacity=5, weight=5)
        G.add_edge(1, 5, capacity=2, weight=12)
        G.add_edge(2, 5, capacity=4, weight=4)
        G.add_edge(2, 6, capacity=2, weight=6)
        G.add_edge(3, 6, capacity=31, weight=3)
        G.add_edge(4, 5, capacity=18, weight=4)
        G.add_edge(5, 6, capacity=9, weight=5)
        G.add_edge(4, 't', capacity=3)
        G.add_edge(5, 't', capacity=7)
        G.add_edge(6, 't', capacity=22)
        flow = nx.max_flow_min_cost(G, 's', 't')
        soln = {1: {2: 6, 4: 5, 5: 1},
                2: {3: 6, 5: 4, 6: 2},
                3: {6: 20},
                4: {5: 2, 't': 3},
                5: {6: 0, 't': 7},
                6: {'t': 22},
                's': {1: 12, 2: 6, 3: 14},
                't': {}}
        assert_equal(flow, soln)

        G.add_edge('t', 's', weight=-100)
        flowCost, flow = nx.capacity_scaling(G)
        G.remove_edge('t', 's')
        assert_equal(flow['t']['s'], 32)
        assert_equal(flowCost, -3007)
        del flow['t']['s']
        assert_equal(flow, soln)
        assert_equal(nx.cost_of_flow(G, flow), 193)