Refactor Bridges debug (#1151)

Author: blegat

.travis.yml

@@ -6,7 +6,7 @@ os:
 #  - osx
 julia:
   - 1.0
-  - 1.4
+  - 1
 notifications:
   email: false
 git:

src/Bridges/debug.jl

@@ -10,12 +10,21 @@ function print_node(io::IO, b::LazyBridgeOptimizer, node::ObjectiveNode)
     F, = b.objective_types[node.index]
     MOIU.print_with_acronym(io, "|$(node.index)| objective function of type `$F` is")
 end
-function print_node_info(io::IO, b::LazyBridgeOptimizer, node::AbstractNode)
+function print_node_info(
+    io::IO, b::LazyBridgeOptimizer, node::AbstractNode;
+    debug_unsupported = false
+)
     print(io, " ")
     print_node(io, b, node)
     d = _dist(b.graph, node)
     if d == INFINITY
-        print(io, " not supported\n")
+        print(io, " not supported")
+        if debug_unsupported
+            print(io, " because")
+            print_unsupported(io, b, node)
+        else
+            println(io)
+        end
     else
         index = bridge_index(b.graph, node)
         if iszero(index) || (node isa VariableNode && !is_variable_edge_best(b.graph, node))
@@ -28,44 +37,47 @@ function print_node_info(io::IO, b::LazyBridgeOptimizer, node::AbstractNode)
         end
     end
 end
-print_graph(b::LazyBridgeOptimizer) = print_graph(Base.stdout, b)
-function print_graph(io::IO, b::LazyBridgeOptimizer)
+print_graph(b::LazyBridgeOptimizer; kws...) = print_graph(Base.stdout, b; kws...)
+function print_graph(io::IO, b::LazyBridgeOptimizer; kws...)
     println(io, b.graph)
-    for node in variable_nodes(b.graph)
-        print_node_info(io, b, node)
+    print_nodes(io, b, variable_nodes(b.graph), constraint_nodes(b.graph), objective_nodes(b.graph); kws...)
+end
+function print_nodes(io::IO, b::LazyBridgeOptimizer, variable_nodes, constraint_nodes, objective_nodes; kws...)
+    for node in variable_nodes
+        print_node_info(io, b, node; kws...)
     end
-    for node in constraint_nodes(b.graph)
-        print_node_info(io, b, node)
+    for node in constraint_nodes
+        print_node_info(io, b, node; kws...)
     end
-    for node in objective_nodes(b.graph)
-        print_node_info(io, b, node)
+    for node in objective_nodes
+        print_node_info(io, b, node; kws...)
     end
 end
 
-function print_unsupported(io::IO, b::LazyBridgeOptimizer, node::AbstractNode)
+function print_if_unsupported(io::IO, b::LazyBridgeOptimizer, node::AbstractNode)
     if _dist(b.graph, node) != INFINITY
         return
     end
-    print(io, "  ")
+    print(io, "   ")
     print_node(io, b, node)
     print(io, " not supported\n")
 end
 function print_unsupported(io::IO, b::LazyBridgeOptimizer, edge::Edge)
     for node in edge.added_variables
-        print_unsupported(io, b, node)
+        print_if_unsupported(io, b, node)
     end
     for node in edge.added_constraints
-        print_unsupported(io, b, node)
+        print_if_unsupported(io, b, node)
     end
 end
 function print_unsupported(io::IO, b::LazyBridgeOptimizer, edge::ObjectiveEdge)
     for node in edge.added_variables
-        print_unsupported(io, b, node)
+        print_if_unsupported(io, b, node)
     end
     for node in edge.added_constraints
-        print_unsupported(io, b, node)
+        print_if_unsupported(io, b, node)
     end
-    print_unsupported(io, b, edge.added_objective)
+    print_if_unsupported(io, b, edge.added_objective)
 end
 function print_unsupported(io::IO, b::LazyBridgeOptimizer, edges::Vector, index_to_bridge::Function)
     no_bridge = true
@@ -74,7 +86,7 @@ function print_unsupported(io::IO, b::LazyBridgeOptimizer, edges::Vector, index_
             println(io, ":")
             no_bridge = false
         end
-        MOIU.print_with_acronym(io, "  Cannot use `$(index_to_bridge(edge.bridge_index))` because:\n")
+        MOIU.print_with_acronym(io, "   Cannot use `$(index_to_bridge(edge.bridge_index))` because:\n")
         print_unsupported(io, b, edge)
     end
     if no_bridge
@@ -90,34 +102,26 @@ end
 function _bridge_type(b::LazyBridgeOptimizer, node::ObjectiveNode, bridge_index::Int)
     return Objective.concrete_bridge_type(b.objective_bridge_types[bridge_index], b.objective_types[node.index]...)
 end
-function print_unsupported(io::IO, b::LazyBridgeOptimizer, variables, constraints, objectives)
-    for node in variables
-        print_node(io, b, node)
-        print(io, " not supported because")
-        print_unsupported(io, b, b.graph.variable_edges[node.index],
-                          bridge_index -> _bridge_type(b, node, bridge_index))
-        print(io, "  Cannot add free variables and then constrain them because")
-        constraint_node = b.graph.variable_constraint_node[node.index]
-        if constraint_node.index == -1
-            println(io, " free variables are bridged but no functionize bridge was added.")
-        else
-            println(io, ":")
-            print_unsupported(io, b, constraint_node)
-        end
-    end
-    for node in constraints
-        print_node(io, b, node)
-        print(io, " not supported because")
-        print_unsupported(io, b, b.graph.constraint_edges[node.index],
-                          bridge_index -> _bridge_type(b, node, bridge_index))
-    end
-    for node in objectives
-        print_node(io, b, node)
-        print(io, " not supported because")
-        print_unsupported(io, b, b.graph.objective_edges[node.index],
-                          bridge_index -> _bridge_type(b, node, bridge_index))
+function print_unsupported(io::IO, b::LazyBridgeOptimizer, node::VariableNode)
+    print_unsupported(io, b, b.graph.variable_edges[node.index],
+                      bridge_index -> _bridge_type(b, node, bridge_index))
+    print(io, "   Cannot add free variables and then constrain them because")
+    constraint_node = b.graph.variable_constraint_node[node.index]
+    if constraint_node.index == -1
+        println(io, " free variables are bridged but no functionize bridge was added.")
+    else
+        println(io, ":")
+        print_if_unsupported(io, b, constraint_node)
     end
 end
+function print_unsupported(io::IO, b::LazyBridgeOptimizer, node::ConstraintNode)
+    print_unsupported(io, b, b.graph.constraint_edges[node.index],
+                      bridge_index -> _bridge_type(b, node, bridge_index))
+end
+function print_unsupported(io::IO, b::LazyBridgeOptimizer, node::ObjectiveNode)
+    print_unsupported(io, b, b.graph.objective_edges[node.index],
+                      bridge_index -> _bridge_type(b, node, bridge_index))
+end
 
 function add_unsupported(graph::Graph, edges::Vector{Edge},
                          variables, constraints, objectives)
@@ -180,7 +184,8 @@ function debug_unsupported(io::IO, b::LazyBridgeOptimizer, node::AbstractNode)
     constraints = Set{ConstraintNode}()
     objectives = Set{ObjectiveNode}()
     add_unsupported(b.graph, node, variables, constraints, objectives)
-    print_unsupported(io, b, _sort(variables), _sort(constraints), _sort(objectives))
+    print_nodes(io, b, _sort(variables), _sort(constraints), _sort(objectives),
+                debug_unsupported = true)
 end
 
 const UNSUPPORTED_MESSAGE = " are not supported and cannot be bridged into supported" *