teile y auf je nachdem ob dazugehöriger Knoten von Grad 1 oder nicht

src/main_iterative_opt.py

@@ -141,7 +141,7 @@ def solve_bipartite_minimization(graph_file):
     nodes_with_degree_higher_one = dict(filter(lambda keyValuePair: len(keyValuePair[1]) > 1, B_nodes_with_associated_A_nodes.items()))
 
     # Erstelle Liste aller Nodes in B mit einem Grad = 1 und 
-    nodes_with_degree_equals_one = {bNode: aNodes[0] for (bNode, aNodes) in B_nodes_with_associated_A_nodes.items() if len(aNodes) == 1}
+    nodes_with_degree_equals_one = [(bNode, aNodes[0]) for (bNode, aNodes) in B_nodes_with_associated_A_nodes.items() if len(aNodes) == 1]
     # Sortiere sie nach ihrem korrospondierenden Knoten Wert von A, dann sind alle Knoten in B mit Grad 1 so sortiert, dass ihre Kanten kreuzungsfrei sind 
     nodes_with_degree_equals_one.sort(key= lambda node: node[1])
     # Erstelle Liste mit nur den Grad 1 Knoten aus B, erleichtert nachher das Filtern der Edges
@@ -161,12 +161,10 @@ def solve_bipartite_minimization(graph_file):
     # Löse Zyklen auf
     # Ende
 
-
-   
-
     prob = LpProblem("Minimize_Crossings", LpMinimize)
     
     # Erstelle Konstanten für die Sortierung 
+    # Variable y(i, j) : Liegt i links von j ? Wenn ja 1, sonst 0.
     # positionalVariablesForDegreeOne = {(nodes_with_degree_equals_one[i], nodes_with_degree_equals_one[i+1]) : LpVariable(f"y_{nodes_with_degree_equals_one[i]}_{nodes_with_degree_equals_one[i+1]}", 0, 1, cat='Binary') for i in range(len(nodes_with_degree_equals_one)-1)}
     # crossingVariablesForDegreeOne = {(i, j, k, l): LpVariable(f"c_{i}_{j}_{k}_{l}", 0, 1, cat='Binary') for (i, j) in edges_of_degree_one_nodes for (k, l) in edges_of_degree_one_nodes}
 
@@ -175,31 +173,37 @@ def solve_bipartite_minimization(graph_file):
     
     # crossingVariablesBetweenMultiAndOne = {}
 
-    # Variable y(i, j) : Liegt i links von j ? Wenn ja 1, sonst 0.
-    positional_vars_without_degree_one_nodes = {}
+    # Für alle Knoten {B | Knoten Grad == 1} x  {B | Knoten Grad == 1}: erstelle Positions variable
+    positional_vars_degree_one_nodes_only = {}
     for nodeX in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1):
-        if not nodeX in nodes_with_degree_equals_one:
+        if nodeX in nodes_with_degree_higher_one:
             continue 
         for nodeY in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1):
-            if not nodeY in nodes_with_degree_equals_one:
+            if nodeY in nodes_with_degree_higher_one:
                 continue
-            if i == j:
+            if nodeX == nodeY:
                 continue
-            positional_vars_without_degree_one_nodes[(nodeX, nodeY)] = LpVariable(f"y_{nodeX}_{nodeY}", 0, 1, cat='Binary')
-            positional_vars_without_degree_one_nodes[(nodeX, nodeY)].setInitialValue(0)
+            positional_vars_degree_one_nodes_only[(nodeX, nodeY)] = LpVariable(f"y_{nodeX}_{nodeY}", 0, 1, cat='Binary')
+            positional_vars_degree_one_nodes_only[(nodeX, nodeY)].setInitialValue(0)
     
+    # Für alle Kanten (a ~ b) : Grad(b) > 1 
+
+
+    positional_vars_with_degree_one_nodes = {}
     # Setze die Variablen, der Knoten, die Grad 1 haben so, dass die Ordnung bereits vorgegeben ist (Hoffnung hier ist, dass damit der Solver schon mit einer besseren Lösung anfangen kann, weil er dieses triviale Probem nicht zusätzlich lösen muss)
-    for i in range(len(nodes_with_degree_equals_one)-1):
-        positional_vars_without_degree_one_nodes[(nodes_with_degree_equals_one[i][0], nodes_with_degree_equals_one[i+1][0])].setInitialValue(1)
+    # for i in range(len(nodes_with_degree_equals_one)-1):
+    #     positional_vars_with_degree_one_nodes[(nodes_with_degree_equals_one[i][0], nodes_with_degree_equals_one[i+1][0])].setInitialValue(1)
     
     # Erstelle die Crossing constraints für die Kanten, die an Knoten liegen, die Grad = 1 haben
-    for (nodeB, nodeA) in nodes_with_degree_equals_one:
-        for (k, l) in edges:
+    # for (nodeB, nodeA) in nodes_with_degree_equals_one:
+    #     for (k, l) in edges:
+
             
-    positionalVariables = {(i, j): LpVariable(f"y_{i}_{j}", 0, 1, cat='Binary') for i in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1) for j in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1) if i != j}
+    positionalVariables = {(i, j): LpVariable(f"y_{i}_{j}", 0, 1, cat='Binary') for i in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1) for j in range(number_of_nodes_in_A + 1, number_of_nodes_in_A + number_of_nodes_in_B + 1) if i != j and not (i, j) in positional_vars_degree_one_nodes_only}
     # Variable c(i,j,k,l) : Kreuzt die Kante zwischen i-j die Kante zwischen k-l
     crossingVariables = {(i, j, k, l): LpVariable(f"c_{i}_{j}_{k}_{l}", 0, 1, cat='Binary') for (i, j) in edges for (k, l) in edges}
     logging.info("y und c geladen.")
+    logging.info(f"Positions Variablen y: gesamt erwartet {number_of_nodes_in_B * (number_of_nodes_in_B - 1)}, davon wirklich gesamt {len(positional_vars_degree_one_nodes_only) + len(positionalVariables)}, für Knoten mit Grad 1: {len(positional_vars_degree_one_nodes_only)}, für Knoten mit Grad > 1: {len(positionalVariables)}")
 
     prob += lpSum(crossingVariables.values())
     logging.info("Zielfunktion aufgestellt.")