def test_multidigraph_ignore(self): G = nx.MultiDiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation='ignore')) x_ = [(0, 1, 0, FORWARD), (1, 0, 0, FORWARD)] # or (1, 0, 1, 1) assert_equal(x[0], x_[0]) assert_equal(x[1][:2], x_[1][:2]) assert_equal(x[1][3], x_[1][3])
def test_multigraph(self): G = nx.MultiGraph(self.edges) x = list(find_cycle(G, self.nodes)) x_ = [(0, 1, 0), (1, 0, 1)] # or (1, 0, 2) # Hash randomization...could be any edge. assert_equal(x[0], x_[0]) assert_equal(x[1][:2], x_[1][:2])
def test_dag(self): G = nx.DiGraph([(0, 1), (0, 2), (1, 2)]) pytest.raises( nx.exception.NetworkXNoCycle, find_cycle, G, orientation="original" ) x = list(find_cycle(G, orientation="ignore")) assert x == [(0, 1, FORWARD), (1, 2, FORWARD), (0, 2, REVERSE)]
def test_multidigraph_ignore(self): G = nx.MultiDiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation="ignore")) x_ = [(0, 1, 0, FORWARD), (1, 0, 0, FORWARD)] # or (1, 0, 1, 1) assert x[0] == x_[0] assert x[1][:2] == x_[1][:2] assert x[1][3] == x_[1][3]
def resolve(edges, order): graph = DiGraph() graph.add_edges_from(edges) removed = [] for node in order: try: find_cycle(graph) graph.remove_node(node) removed.append(node) except NetworkXNoCycle: break return RESOLVE_RESULT([*graph.node, *removed], removed, sum(COSTS[key] for key in removed))
def test_dag(self): G = nx.DiGraph([(0, 1), (0, 2), (1, 2)]) assert_raises(nx.exception.NetworkXNoCycle, find_cycle, G, orientation='original') x = list(find_cycle(G, orientation='ignore')) assert_equal(x, [(0, 1, FORWARD), (1, 2, FORWARD), (0, 2, REVERSE)])
def _ancestors_in_topological_sort_order(module_name): ancestral_module_names = ancestors(_dependency_graph, module_name) subgraph = _dependency_graph.subgraph(ancestral_module_names) try: sorted_nodes = topological_sort(subgraph) except nx.NetworkXUnfeasible as ex: try: cycle = find_cycle(subgraph) except Exception as ex: log_error(f'find_cycle: error: {ex.__class__.__name__}({ex})') else: log_error(f'cycle: {cycle}') finally: raise else: return list(reversed(list(sorted_nodes)))
def _build_diagram( g_sel, avl_att, tgt_att=None, imputation_nodes=True, merge_nodes=False, prune=False, test=False, ): if imputation_nodes: q_desc = np.where(avl_att)[0] for g in g_sel: add_imputation_nodes(g, q_desc) q_diagram = compose_all(g_sel) if merge_nodes: add_merge_nodes(q_diagram) if prune: assert tgt_att is not None, "If you prune, you need to provide tgt_att" q_targ = np.where(tgt_att)[0] _prune(q_diagram, q_targ) if test: try: cycles = find_cycle(q_diagram) msg = """ Found a cycle! Cycle was: {} """.format(cycles) raise ValueError(msg) except NetworkXNoCycle: pass q_diagram.graph["desc_ids"] = get_ids(q_diagram, kind="desc") q_diagram.graph["targ_ids"] = get_ids(q_diagram, kind="targ") return q_diagram
def test_multidigraph_ignore2(self): # Loop traversed an edge while ignoring its orientation. G = nx.MultiDiGraph([(0, 1), (1, 2), (1, 2)]) x = list(find_cycle(G, [0, 1, 2], orientation='ignore')) x_ = [(1, 2, 0, FORWARD), (1, 2, 1, REVERSE)] assert_equal(x, x_)
def test_graph_orientation_none(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes, orientation=None)) x_ = [(0, 1), (1, 2), (2, 0)] assert_equal(x, x_)
def test_digraph_ignore(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation='ignore')) x_ = [(0, 1, FORWARD), (1, 0, FORWARD)] assert_equal(x, x_)
def test_graph_cycle(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes)) x_ = [(0, 1), (1, 2), (2, 0)] assert x == x_
def test_graph_cycle(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes)) x_ = [(0, 1), (1, 2), (2, 0)] assert_equal(x, x_)
def test_digraph_reverse(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation="reverse")) x_ = [(1, 0, REVERSE), (0, 1, REVERSE)] assert x == x_
def test_digraph_orientation_original(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation="original")) x_ = [(0, 1, FORWARD), (1, 0, FORWARD)] assert x == x_
def test_digraph_orientation_none(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation=None)) x_ = [(0, 1), (1, 0)] assert x == x_
def test_graph_orientation_original(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes, orientation="original")) x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 0, FORWARD)] assert x == x_
def test_graph_orientation_none(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes, orientation=None)) x_ = [(0, 1), (1, 2), (2, 0)] assert x == x_
def test_digraph(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes)) x_ = [(0, 1), (1, 0)] assert_equal(x, x_)
def test_digraph_orientation_none(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation=None)) x_ = [(0, 1), (1, 0)] assert_equal(x, x_)
def test_multidigraph(self): G = nx.MultiDiGraph(self.edges) x = list(find_cycle(G, self.nodes)) x_ = [(0, 1, 0), (1, 0, 0)] # (1, 0, 1) assert_equal(x[0], x_[0]) assert_equal(x[1][:2], x_[1][:2])
def find_po_and_prop1_allocation(Gx: bipartite, fpo_alloc: FractionalAllocation, items: Bundle) -> FractionalAllocation: """ This function implements the algorithm starting at step 3. INPUT: * Gx - An acyclic consumption graph: a bipartite graph describing which agent consumes which object. * fpo_alloc: A fractionally-Pareto-optimal fractional allocation corresponding to the given consumption graph. NOTE: Converting a general allocation to an fPO allocation with an acyclic consumption graph should be done by a different algorithm in a previous step (step 2). * items: Set of items to allocate. OUTPUT: * Fractional allocation which is an integral allocation (since all fractions are 0.0 or 1.0), which is PO and PROP1 First example: Case 1: Only one player(must get everything),Items with positive utility. >>> agent1 = AdditiveAgent({"x": 1, "y": 2, "z": 4}, name="agent1") >>> list_of_agents_for_func = [agent1] >>> items_for_func ={'x','y','z'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'x':1.0,'y':1.0, 'z':1.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node('x') >>> G.add_node('y') >>> G.add_node('z') >>> G.add_edge(agent1, 'x') >>> G.add_edge(agent1, 'y') >>> G.add_edge(agent1, 'z') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) agent1's bundle: {x,y,z}, value: 7.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Case 2: Only one player(must get everything),Items with negative utility. >>> agent1= AdditiveAgent({"x": -1, "y": -2, "z": -4}, name="agent1") >>> list_of_agents_for_func = [agent1] >>> items_for_func ={'x','y','z'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'x':1.0,'y':1.0, 'z':1.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node('x') >>> G.add_node('y') >>> G.add_node('z') >>> G.add_edge(agent1, 'x') >>> G.add_edge(agent1, 'y') >>> G.add_edge(agent1, 'z') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) agent1's bundle: {x,y,z}, value: -7.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Case 3: Only one player(must get everything),Items with negative and positive utilitys. >>> agent1 = AdditiveAgent({"x": -1, "y": 2, "z": -4}, name="agent1") >>> list_of_agents_for_func = [agent1] >>> items_for_func ={'x','y','z'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'x':1.0,'y':1.0, 'z':1.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node('x') >>> G.add_node('y') >>> G.add_node('z') >>> G.add_edge(agent1, 'x') >>> G.add_edge(agent1, 'y') >>> G.add_edge(agent1, 'z') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) agent1's bundle: {x,y,z}, value: -3.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Second example: (example 3 in the second part of the work) >>> agent1 = AdditiveAgent({"a": 10, "b": 100, "c": 80, "d": -100}, name="agent1") >>> agent2 = AdditiveAgent({"a": 20, "b": 100, "c": -40, "d": 10}, name="agent2") >>> G = nx.Graph() >>> all_agents = [agent1, agent2] >>> all_items = {'a', 'b', 'c', 'd'} >>> G.add_nodes_from(all_agents + list(all_items)) >>> G.add_edges_from([[agent1, 'b'], [agent1, 'c'], [agent2, 'a'], [agent2, 'b'], [agent2, 'd']]) >>> alloc_y_for_func = FractionalAllocation(all_agents, [{'a':0.0,'b':0.3,'c':1.0,'d':0.0},{'a':1.0,'b':0.7,'c':0.0,'d':1.0}]) >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, all_items) >>> print(alloc) agent1's bundle: {b,c}, value: 180.0 agent2's bundle: {a,d}, value: 30.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Third example: Case 1: (example 5 in the second part of the work) >>> agent1= AdditiveAgent({"a": 100, "b": 10, "c": 50, "d": 100 ,"e": 70,"f": 100, "g": 300, "h": 40, "i": 30}, name="agent1") >>> agent2= AdditiveAgent({"a": 20, "b": 20, "c": 40, "d": 90 ,"e": 90,"f": 100, "g": 30, "h": 80, "i": 90}, name="agent2") >>> agent3= AdditiveAgent({"a": 10, "b": 30, "c": 30, "d": 40 ,"e": 180,"f": 100, "g": 300, "h": 20, "i": 90}, name="agent3") >>> agent4= AdditiveAgent({"a": 200, "b": 40, "c": 20, "d": 80 ,"e": 300,"f": 100, "g": 30, "h": 60, "i": 180}, name="agent4") >>> agent5= AdditiveAgent({"a": 50, "b": 50, "c": 10, "d": 60 ,"e": 90,"f": 100, "g": 300, "h": 120, "i": 180}, name="agent5") >>> list_of_agents_for_func = [agent1, agent2, agent3, agent4, agent5] >>> items_for_func = {'a','b','c','d','e','f','g','h','i'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'a':0.0,'b':0.0,'c':1.0,'d':1.0,'e':0.0,'f':0.2,'g':0.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.8,'f':0.4,'g':0.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.2,'g':1.0,'h':0.0,'i':0.0},{'a':1.0,'b':0.0,'c':0.0,'d':0.0,'e':0.2,'f':0.0,'g':0.0,'h':0.0,'i':0.0},{'a':0.0,'b':1.0,'c':0.0,'d':0.0,'e':0.0,'f':0.2,'g':0.0,'h':1.0,'i':1.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node(agent2) >>> G.add_node(agent3) >>> G.add_node(agent4) >>> G.add_node(agent5) >>> G.add_node('a') >>> G.add_node('b') >>> G.add_node('c') >>> G.add_node('d') >>> G.add_node('e') >>> G.add_node('f') >>> G.add_node('g') >>> G.add_node('h') >>> G.add_node('i') >>> G.add_edge(agent1, 'c') >>> G.add_edge(agent1, 'd') >>> G.add_edge(agent1, 'f') >>> G.add_edge(agent2, 'e') >>> G.add_edge(agent2, 'f') >>> G.add_edge(agent3, 'f') >>> G.add_edge(agent3, 'g') >>> G.add_edge(agent4, 'a') >>> G.add_edge(agent4, 'e') >>> G.add_edge(agent5, 'b') >>> G.add_edge(agent5, 'h') >>> G.add_edge(agent5, 'i') >>> G.add_edge(agent5, 'f') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> # print(alloc) # Below is ONE possible output. # agent1's bundle: {c,d,f}, value: 250.0 # agent2's bundle: {e}, value: 90.0 # agent3's bundle: {g}, value: 300.0 # agent4's bundle: {a}, value: 200.0 # agent5's bundle: {b,h,i}, value: 350.0 # <BLANKLINE> >>> alloc.is_complete_allocation() True Case 2: (example 4 in the second part of the work) >>> agent1= AdditiveAgent({"a": -100, "b": -10, "c": -50, "d":-100 ,"e": -70,"f": -100, "g": -200, "h": -40, "i": -30}, name="agent1") >>> agent2= AdditiveAgent({"a": -20, "b": -20, "c": -40, "d": -90 ,"e": -90,"f": -100, "g": -100, "h": -80, "i": -90}, name="agent2") >>> agent3= AdditiveAgent({"a": -10, "b": -30, "c": -30, "d": -40 ,"e": -180,"f": -100, "g": -200, "h": -20, "i": -90}, name="agent3") >>> agent4= AdditiveAgent({"a": -200, "b": -40, "c": -20, "d": -80 ,"e": -300,"f": -100, "g": -100, "h": -60, "i": -180}, name="agent4") >>> agent5= AdditiveAgent({"a": -50, "b": -50, "c": -10, "d": -60 ,"e": -90,"f": -100, "g": -200, "h": -120, "i": -180}, name="agent5") >>> list_of_agents_for_func = [agent1, agent2, agent3, agent4, agent5] >>> items_for_func = {'a','b','c','d','e','f','g','h','i'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'a':0.0,'b':1.0,'c':0.0,'d':0.0,'e':1.0,'f':0.2,'g':0.0,'h':0.0,'i':1.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.2,'g':0.0,'h':0.0,'i':0.0},{'a':1.0,'b':0.0,'c':0.0,'d':1.0,'e':0.0,'f':0.2,'g':0.0,'h':1.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.2,'g':1.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':1.0,'d':0.0,'e':0.0,'f':0.2,'g':0.0,'h':0.0,'i':0.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node(agent2) >>> G.add_node(agent3) >>> G.add_node(agent4) >>> G.add_node(agent5) >>> G.add_node('a') >>> G.add_node('b') >>> G.add_node('c') >>> G.add_node('d') >>> G.add_node('e') >>> G.add_node('f') >>> G.add_node('g') >>> G.add_node('h') >>> G.add_node('i') >>> G.add_edge(agent1, 'b') >>> G.add_edge(agent1, 'e') >>> G.add_edge(agent1, 'f') >>> G.add_edge(agent1, 'i') >>> G.add_edge(agent2, 'f') >>> G.add_edge(agent3, 'a') >>> G.add_edge(agent3, 'd') >>> G.add_edge(agent3, 'f') >>> G.add_edge(agent3, 'h') >>> G.add_edge(agent4, 'g') >>> G.add_edge(agent4, 'f') >>> G.add_edge(agent5, 'c') >>> G.add_edge(agent5, 'f') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) #in my example I gave f to agent1, but the algorithm gave it to agent2 agent1's bundle: {b,e,i}, value: -110.0 agent2's bundle: {f}, value: -100.0 agent3's bundle: {a,d,h}, value: -70.0 agent4's bundle: {g}, value: -100.0 agent5's bundle: {c}, value: -10.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Case 3: (example 6 in the second part of the work) >>> agent1= AdditiveAgent({"a": -100, "b": 10, "c": 50, "d": -100 ,"e": 70,"f": 300, "g": -300, "h": -40, "i": 30}, name="agent1") >>> agent2= AdditiveAgent({"a": 20, "b": 20, "c": -40, "d": 90 ,"e": -90,"f": -100, "g": 300, "h": 80, "i": 90}, name="agent2") >>> agent3= AdditiveAgent({"a": 10, "b": -30, "c": 30, "d": 40 ,"e": 180,"f": 300, "g": 30, "h": 20, "i": -90}, name="agent3") >>> agent4= AdditiveAgent({"a": -200, "b": 40, "c": -20, "d": 80 ,"e": -300,"f": 300, "g": 300, "h": 60, "i": -180}, name="agent4") >>> agent5= AdditiveAgent({"a": 50, "b": 50, "c": 10, "d": 60 ,"e": 90,"f": 100, "g": 300, "h": -120, "i": 180}, name="agent5") >>> list_of_agents_for_func = [agent1, agent2, agent3, agent4, agent5] >>> items_for_func = {'a','b','c','d','e','f','g','h','i'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'a':0.0,'b':0.0,'c':1.0,'d':0.0,'e':0.0,'f':0.4,'g':0.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':1.0,'e':0.0,'f':0.0,'g':0.5,'h':1.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':1.0,'f':0.4,'g':0.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.0,'g':0.5,'h':0.0,'i':0.0},{'a':1.0,'b':1.0,'c':0.0,'d':0.0,'e':0.0,'f':0.2,'g':0.0,'h':0.0,'i':1.0}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node(agent2) >>> G.add_node(agent3) >>> G.add_node(agent4) >>> G.add_node(agent5) >>> G.add_node('a') >>> G.add_node('b') >>> G.add_node('c') >>> G.add_node('d') >>> G.add_node('e') >>> G.add_node('f') >>> G.add_node('g') >>> G.add_node('h') >>> G.add_node('i') >>> G.add_edge(agent1, 'c') >>> G.add_edge(agent1, 'f') >>> G.add_edge(agent2, 'd') >>> G.add_edge(agent2, 'h') >>> G.add_edge(agent2, 'g') >>> G.add_edge(agent3, 'e') >>> G.add_edge(agent3, 'f') >>> G.add_edge(agent4, 'g') >>> G.add_edge(agent5, 'a') >>> G.add_edge(agent5, 'b') >>> G.add_edge(agent5, 'i') >>> G.add_edge(agent5, 'f') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) agent1's bundle: {c,f}, value: 350.0 agent2's bundle: {d,g,h}, value: 470.0 agent3's bundle: {e}, value: 180.0 agent4's bundle: {}, value: 0.0 agent5's bundle: {a,b,i}, value: 280.0 <BLANKLINE> >>> alloc.is_complete_allocation() True Fourth example: A general situation, in which the new division is indeed a pareto improvement of the original division (example 7 in the second part of the work) >>> agent1= AdditiveAgent({"a": -100, "b": 10, "c": 50, "d": -100 ,"e": 70,"f": 100, "g": -300, "h": -40, "i": 30}, name="agent1") >>> agent2= AdditiveAgent({"a": 20, "b": 20, "c": -40, "d": 90 ,"e": -90,"f": -100, "g": 30, "h": 80, "i": 90}, name="agent2") >>> agent3= AdditiveAgent({"a": 10, "b": -30, "c": 30, "d": 40 ,"e": 180,"f": 100, "g": 300, "h": 20, "i": -90}, name="agent3") >>> agent4= AdditiveAgent({"a": -200, "b": 40, "c": -20, "d": 80 ,"e": -300,"f": 100, "g": 30, "h": 60, "i": -180}, name="agent4") >>> agent5= AdditiveAgent({"a": 50, "b": 50, "c": 10, "d": 60 ,"e": 90,"f": -100, "g": 300, "h": -120, "i": 180}, name="agent5") >>> list_of_agents_for_func = [agent1, agent2, agent3, agent4, agent5] >>> items_for_func = {'a','b','c','d','e','f','g','h','i'} >>> alloc_y_for_func = FractionalAllocation(list_of_agents_for_func, [{'a':0.0,'b':1.0,'c':0.0,'d':0.0,'e':1.0,'f':1.0,'g':0.0,'h':0.0,'i':0.4},{'a':0.0,'b':0.0,'c':0.0,'d':1.0,'e':0.0,'f':0.0,'g':0.0,'h':1.0,'i':0.0},{'a':0.0,'b':0.0,'c':1.0,'d':0.0,'e':0.0,'f':0,'g':1.0,'h':0.0,'i':0.0},{'a':0.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.0,'g':0.0,'h':0.0,'i':0.0},{'a':1.0,'b':0.0,'c':0.0,'d':0.0,'e':0.0,'f':0.0,'g':0.0,'h':0.0,'i':0.6}]) >>> G = nx.Graph() >>> G.add_node(agent1) >>> G.add_node(agent2) >>> G.add_node(agent3) >>> G.add_node(agent4) >>> G.add_node(agent5) >>> G.add_node('a') >>> G.add_node('b') >>> G.add_node('c') >>> G.add_node('d') >>> G.add_node('e') >>> G.add_node('f') >>> G.add_node('g') >>> G.add_node('h') >>> G.add_node('i') >>> G.add_edge(agent1, 'e') >>> G.add_edge(agent1, 'b') >>> G.add_edge(agent1, 'f') >>> G.add_edge(agent1, 'i') >>> G.add_edge(agent2, 'd') >>> G.add_edge(agent2, 'h') >>> G.add_edge(agent3, 'c') >>> G.add_edge(agent3, 'g') >>> G.add_edge(agent5, 'a') >>> G.add_edge(agent5, 'i') >>> alloc = find_po_and_prop1_allocation(G, alloc_y_for_func, items_for_func) >>> print(alloc) agent1's bundle: {b,e,f,i}, value: 210.0 agent2's bundle: {d,h}, value: 170.0 agent3's bundle: {c,g}, value: 330.0 agent4's bundle: {}, value: 0.0 agent5's bundle: {a}, value: 50.0 <BLANKLINE> >>> alloc.is_complete_allocation() True """ # Check input try: find_cycle(Gx) raise Exception("There are cycles in the given graph") except nx.NetworkXNoCycle: pass #Algorithm Q = queue.Queue() while Gx.number_of_edges() > len( items ): #If each item belongs to exactly one agent, the number of edges in the graph will necessarily be the same as the number of items agent = find_agent_sharing_item(Gx, items) Q.put( agent ) #Because of the deletion of edges in the graph we will never put again an agent who has previously entered Q while len(Q.queue) != 0: #If the queue is not empty curr_agent = Q.get(0) #Get the first agent from the queue dict_of_items_curr_agent_share = get_dict_of_items_curr_agent_share( curr_agent, fpo_alloc) add_neighbors_to_Q(Q, dict_of_items_curr_agent_share) if dict_of_items_curr_agent_share != {}: #Check that the agent is actually sharing items for item, agents in dict_of_items_curr_agent_share.items(): if curr_agent.value(item) > 0: #If a positive utility update_fpo_alloc_and_Gx( curr_agent, item, agents, fpo_alloc, Gx) #Gave to the curr_agent the item else: #If a negative utility other_agent = agents[0] #Gave another agent the item agents.remove(other_agent) agents.append(curr_agent) update_fpo_alloc_and_Gx(other_agent, item, agents, fpo_alloc, Gx) return fpo_alloc
def test_graph_orientation_original(self): G = nx.Graph(self.edges) G.add_edge(2, 0) x = list(find_cycle(G, self.nodes, orientation='original')) x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 0, FORWARD)] assert_equal(x, x_)
def test_digraph_reverse(self): G = nx.DiGraph(self.edges) x = list(find_cycle(G, self.nodes, orientation='reverse')) x_ = [(1, 0, REVERSE), (0, 1, REVERSE)] assert_equal(x, x_)