networkx 0.1.1 → 0.2.0

data/lib/networkx/operators/binary.rb

@@ -1,227 +1,205 @@
-# TODO: Reduce module length
-
 module NetworkX
   # Returns the edges of the graph in an array
   def self.get_edges(graph)
     edges = []
-    graph.adj.each do |u, u_attrs|
-      u_attrs.each do |v, uv_attrs|
-        edges << [u, v, uv_attrs]
+    if graph.is_a?(MultiGraph)
+      graph.adj.each do |u, v_keys|
+        v_keys.each do |v, key_attrs|
+          next if u > v
+
+          key_attrs.each do |_key, attributes|
+            edges << [u, v, attributes]
+          end
+        end
+      end
+    else
+      graph.adj.each do |u, u_attrs|
+        u_attrs.each do |v, uv_attrs|
+          edges << [u, v, uv_attrs]
+        end
       end
     end
     edges
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Transforms the labels of the nodes of the graphs
   # so that they are disjoint.
-  def self.convert_to_distinct_labels(graph, starting_int=-1)
-    new_graph = Marshal.load(Marshal.dump(graph))
-    new_graph.clear
+  def self.convert_to_distinct_labels(graph, starting_int = -1)
+    new_graph = graph.class.new
 
-    idx_dict = Hash[graph.nodes.keys.map do |v|
+    idx_dict = graph.nodes.keys.to_h do |v|
       starting_int += 1
       [v, starting_int]
-    end]
+    end
 
     graph.nodes.each do |u, attrs|
-      new_graph.add_node(u.to_s + idx_dict[u].to_s, attrs)
+      new_graph.add_node(u.to_s + idx_dict[u].to_s, **attrs)
     end
 
     graph.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
         if graph.multigraph?
           uv_attrs.each do |_k, attrs|
-            new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, attrs)
+            new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, **attrs)
           end
         else
-          new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, uv_attrs)
+          new_graph.add_edge(u.to_s + idx_dict[u].to_s, v.to_s + idx_dict[v].to_s, **uv_attrs)
         end
       end
     end
     new_graph
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs the intersection of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the intersection of the two graphs
-  def self.intersection(g_1, g_2)
-    result = Marshal.load(Marshal.dump(g_1))
-    result.clear
-
-    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g_1.nodes.keys - g_2.nodes.keys).empty?
-
-    g_1.nodes.each { |u, attrs| result.add_node(u, attrs) }
-
-    if g_1.number_of_edges <= g_2.number_of_edges
-      g_1.adj.each do |u, u_edges|
-        u_edges.each do |v, uv_attrs|
-          if g_1.multigraph?
-            uv_attrs.each do |k, attrs|
-              result.add_edge(u, v, attrs) if g_2.edge?(u, v, k)
-            end
-          elsif g_2.edge?(u, v)
-            result.add_edge(u, v, uv_attrs)
-          end
-        end
-      end
-    else
-      g_2.adj.each do |u, u_edges|
-        u_edges.each do |v, uv_attrs|
-          if g_2.multigraph?
-            uv_attrs.each do |k, attrs|
-              result.add_edge(u, v, attrs) if g_1.edge?(u, v, k)
-            end
-          elsif g_1.edge?(u, v)
-            result.add_edge(u, v, uv_attrs)
+  def self.intersection(g1, g2)
+    result = g1.class.new
+
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
+    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
+
+    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
+
+    g1, g2 = g2, g1 if g1.number_of_edges > g2.number_of_edges
+    g1.adj.each do |u, u_edges|
+      u_edges.each do |v, uv_attrs|
+        if g1.multigraph?
+          next if u > v && g1.instance_of?(MultiGraph)
+
+          uv_attrs.each do |k, attrs|
+            result.add_edge(u, v, **attrs) if g2.edge?(u, v, k)
           end
+        elsif g2.edge?(u, v)
+          result.add_edge(u, v, **uv_attrs)
         end
       end
     end
     result
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs the difference of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the difference of the two graphs
-  def self.difference(g_1, g_2)
-    result = Marshal.load(Marshal.dump(g_1))
-    result.clear
+  def self.difference(g1, g2)
+    result = g1.class.new
 
-    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g_1.nodes.keys - g_2.nodes.keys).empty?
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
+    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
 
-    g_1.nodes.each { |u, attrs| result.add_node(u, attrs) }
+    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
 
-    g_1.adj.each do |u, u_edges|
+    g1.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
-        if g_1.multigraph?
+        if g1.multigraph?
+          next if u > v && g1.instance_of?(MultiGraph)
+
           uv_attrs.each do |k, attrs|
-            result.add_edge(u, v, attrs) unless g_2.edge?(u, v, k)
+            result.add_edge(u, v, **attrs) unless g2.edge?(u, v, k)
           end
         else
-          result.add_edge(u, v, uv_attrs) unless g_2.edge?(u, v)
+          result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
         end
       end
     end
     result
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs the symmetric difference of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the symmetric difference of the two graphs
-  def self.symmetric_difference(g_1, g_2)
-    result = Marshal.load(Marshal.dump(g_1))
-    result.clear
+  def self.symmetric_difference(g1, g2)
+    result = g1.class.new
 
-    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
-    raise ArgumentError, 'Node sets must be equal!' unless (g_1.nodes.keys - g_2.nodes.keys).empty?
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
+    raise ArgumentError, 'Node sets must be equal!' unless (g1.nodes.keys - g2.nodes.keys).empty?
 
-    g_1.nodes.each { |u, attrs| result.add_node(u, attrs) }
+    g1.nodes.each { |u, attrs| result.add_node(u, **attrs) }
 
-    g_1.adj.each do |u, u_edges|
+    g1.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
-        if g_1.multigraph?
+        if g1.multigraph?
+          next if u > v && g1.instance_of?(MultiGraph)
+
           uv_attrs.each do |k, attrs|
-            result.add_edge(u, v, attrs) unless g_2.edge?(u, v, k)
+            result.add_edge(u, v, **attrs) unless g2.edge?(u, v, k)
           end
         else
-          result.add_edge(u, v, uv_attrs) unless g_2.edge?(u, v)
+          result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
         end
       end
     end
 
-    g_2.adj.each do |u, u_edges|
+    g2.adj.each do |u, u_edges|
       u_edges.each do |v, uv_attrs|
-        if g_2.multigraph?
+        next if u > v && g1.instance_of?(MultiGraph)
+
+        if g2.multigraph?
           uv_attrs.each do |k, attrs|
-            result.add_edge(u, v, attrs) unless g_1.edge?(u, v, k)
+            result.add_edge(u, v, **attrs) unless g1.edge?(u, v, k)
           end
         else
-          result.add_edge(u, v, uv_attrs) unless g_1.edge?(u, v)
+          result.add_edge(u, v, **uv_attrs) unless g1.edge?(u, v)
         end
       end
     end
     result
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs the composition of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the composition of the two graphs
-  def self.compose(g_1, g_2)
-    result = Marshal.load(Marshal.dump(g_1))
-    result.clear
+  def self.compose(g1, g2)
+    result = g1.class.new
 
-    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
 
-    result.add_nodes(g_1.nodes.map { |u, attrs| [u, attrs] })
-    result.add_nodes(g_2.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(g1.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(g2.nodes.map { |u, attrs| [u, attrs] })
 
-    if g_1.multigraph?
-      g_1.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, attrs) } } }
-      g_2.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, attrs) } } }
+    if g1.multigraph?
+      g1.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, **attrs) } } }
+      g2.adj.each { |u, e| e.each { |v, uv_edges| uv_edges.each_value { |attrs| result.add_edge(u, v, **attrs) } } }
     else
-      g_1.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, attrs) } }
-      g_2.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, attrs) } }
+      g1.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, **attrs) } }
+      g2.adj.each { |u, u_edges| u_edges.each { |v, attrs| result.add_edge(u, v, **attrs) } }
     end
     result
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Performs the union of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the union of the two graphs
-  def self.union(g_1, g_2)
-    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
-
-    case g_1
-    when NetworkX::MultiGraph
-      new_graph = NetworkX::MultiGraph.new
-    when NetworkX::MultiDiGraph
-      new_graph = NetworkX::MultiDiGraph.new
-    when NetworkX::Graph
-      new_graph = NetworkX::Graph.new
-    when NetworkX::DiGraph
-      new_graph = NetworkX::DiGraph.new
-    end
+  def self.union(g1, g2)
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
 
-    new_graph.graph.merge!(g_1.graph)
-    new_graph.graph.merge!(g_2.graph)
+    new_graph = g1.class.new
+    new_graph.graph.merge!(g1.graph)
+    new_graph.graph.merge!(g2.graph)
 
-    raise ArgumentError, 'Graphs must be disjoint!' unless (g_1.nodes.keys & g_2.nodes.keys).empty?
+    raise ArgumentError, 'Graphs must be disjoint!' unless (g1.nodes.keys & g2.nodes.keys).empty?
 
-    g1_edges = get_edges(g_1)
-    g2_edges = get_edges(g_2)
+    g1_edges = get_edges(g1)
+    g2_edges = get_edges(g2)
 
-    new_graph.add_nodes(g_1.nodes.keys)
+    new_graph.add_nodes(g1.nodes.keys)
     new_graph.add_edges(g1_edges)
-    new_graph.add_nodes(g_2.nodes.keys)
+    new_graph.add_nodes(g2.nodes.keys)
     new_graph.add_edges(g2_edges)
 
     new_graph
@@ -229,16 +207,16 @@ module NetworkX
 
   # Performs the disjoint union of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the disjoint union of the two graphs
-  def self.disjoint_union(g_1, g_2)
-    new_g_1 = convert_to_distinct_labels(g_1)
-    new_g_2 = convert_to_distinct_labels(g_2)
-    result = union(new_g_1, new_g_2)
-    result.graph.merge!(g_1.graph)
-    result.graph.merge!(g_2.graph)
+  def self.disjoint_union(g1, g2)
+    new_g1 = convert_to_distinct_labels(g1)
+    new_g2 = convert_to_distinct_labels(g2)
+    result = union(new_g1, new_g2)
+    result.graph.merge!(g1.graph)
+    result.graph.merge!(g2.graph)
     result
   end
 end

data/lib/networkx/operators/product.rb

@@ -1,8 +1,4 @@
-# TODO: Reduce module length
-
 module NetworkX
-  # TODO: Reduce method length
-
   # Returns the edges of the graph in an array
   def self.edges_in_array(graph)
     edge_array = []
@@ -25,26 +21,26 @@ module NetworkX
   end
 
   # Returns the hash product of two hashes
-  def self.hash_product(hash_1, hash_2)
-    Hash[(hash_1.keys | hash_2.keys).map { |n| [n, [hash_1[n], hash_2[n]]] }]
+  def self.hash_product(hash1, hash2)
+    (hash1.keys | hash2.keys).to_h { |n| [n, [hash1[n], hash2[n]]] }
   end
 
   # Returns the node product of nodes of two graphs
-  def self.node_product(g_1, g_2)
+  def self.node_product(g1, g2)
     n_product = []
-    g_1.nodes.each do |k_1, attrs_1|
-      g_2.nodes.each do |k_2, attrs_2|
-        n_product << [[k_1, k_2], hash_product(attrs_1, attrs_2)]
+    g1.nodes.each do |k1, attrs1|
+      g2.nodes.each do |k2, attrs2|
+        n_product << [[k1, k2], hash_product(attrs1, attrs2)]
       end
     end
     n_product
   end
 
   # Returns the product of directed edges with edges
-  def self.directed_edges_cross_edges(g_1, g_2)
+  def self.directed_edges_cross_edges(g1, g2)
     result = []
-    edges_in_array(g_1).each do |u, v, c|
-      edges_in_array(g_2) do |x, y, d|
+    edges_in_array(g1).each do |u, v, c|
+      edges_in_array(g2).each do |x, y, d|
         result << [[u, x], [v, y], hash_product(c, d)]
       end
     end
@@ -52,10 +48,10 @@ module NetworkX
   end
 
   # Returns the product of undirected edges with edges
-  def self.undirected_edges_cross_edges(g_1, g_2)
+  def self.undirected_edges_cross_edges(g1, g2)
     result = []
-    edges_in_array(g_1).each do |u, v, c|
-      edges_in_array(g_2).each do |x, y, d|
+    edges_in_array(g1).each do |u, v, c|
+      edges_in_array(g2).each do |x, y, d|
         result << [[v, x], [u, y], hash_product(c, d)]
       end
     end
@@ -63,10 +59,10 @@ module NetworkX
   end
 
   # Returns the product of edges with edges
-  def self.edges_cross_nodes(g_1, g_2)
+  def self.edges_cross_nodes(g1, g2)
     result = []
-    edges_in_array(g_1).each do |u, v, d|
-      g_2.nodes.keys.each do |x|
+    edges_in_array(g1).each do |u, v, d|
+      g2.nodes.each_key do |x|
         result << [[u, x], [v, x], d]
       end
     end
@@ -74,10 +70,10 @@ module NetworkX
   end
 
   # Returns the product of directed nodes with edges
-  def self.nodes_cross_edges(g_1, g_2)
+  def self.nodes_cross_edges(g1, g2)
     result = []
-    g_1.nodes.keys.each do |x|
-      edges_in_array(g_2).each do |u, v, d|
+    g1.nodes.each_key do |x|
+      edges_in_array(g2).each do |u, v, d|
         result << [[x, u], [x, v], d]
       end
     end
@@ -85,11 +81,11 @@ module NetworkX
   end
 
   # Returns the product of edges with pairs of nodes
-  def self.edges_cross_nodes_and_nodes(g_1, g_2)
+  def self.edges_cross_nodes_and_nodes(g1, g2)
     result = []
-    edges_in_array(g_1).each do |u, v, d|
-      g_2.nodes.keys.each do |x|
-        g_2.nodes.keys.each do |y|
+    edges_in_array(g1).each do |u, v, d|
+      g2.nodes.each_key do |x|
+        g2.nodes.each_key do |y|
           result << [[u, x], [v, y], d]
         end
       end
@@ -98,10 +94,10 @@ module NetworkX
   end
 
   # Initializes the product graph
-  def self.init_product_graph(g_1, g_2)
-    raise ArgumentError, 'Arguments must be both directed or undirected!' unless g_1.directed? == g_2.directed?
+  def self.init_product_graph(g1, g2)
+    raise ArgumentError, 'Arguments must be both directed or undirected!' unless g1.directed? == g2.directed?
 
-    g = if g_1.multigraph? || g_2.multigraph?
+    g = if g1.multigraph? || g2.multigraph?
           NetworkX::MultiGraph.new
         else
           NetworkX::Graph.new
@@ -112,72 +108,71 @@ module NetworkX
 
   # Returns the tensor product of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the tensor product of the two graphs
-  def self.tensor_product(g_1, g_2)
-    g = init_product_graph(g_1, g_2)
-    g.add_nodes(node_product(g_1, g_2))
-    g.add_edges(directed_edges_cross_edges(g_1, g_2))
-    g.add_edges(undirected_edges_cross_edges(g_1, g_2)) unless g.directed?
+  def self.tensor_product(g1, g2)
+    g = init_product_graph(g1, g2)
+    g.add_nodes(node_product(g1, g2))
+    g.add_edges(directed_edges_cross_edges(g1, g2))
+    g.add_edges(undirected_edges_cross_edges(g1, g2)) unless g.directed?
     g
   end
 
   # Returns the cartesian product of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the cartesian product of the two graphs
-  def self.cartesian_product(g_1, g_2)
-    g = init_product_graph(g_1, g_2)
-    g.add_nodes(node_product(g_1, g_2))
-    g.add_edges(edges_cross_nodes(g_1, g_2))
-    g.add_edges(nodes_cross_edges(g_1, g_2))
+  def self.cartesian_product(g1, g2)
+    g = init_product_graph(g1, g2)
+    g.add_nodes(node_product(g1, g2))
+    g.add_edges(edges_cross_nodes(g1, g2))
+    g.add_edges(nodes_cross_edges(g1, g2))
     g
   end
 
   # Returns the lexicographic product of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the lexicographic product of the two graphs
-  def self.lexicographic_product(g_1, g_2)
-    g = init_product_graph(g_1, g_2)
-    g.add_nodes(node_product(g_1, g_2))
-    g.add_edges(edges_cross_nodes_and_nodes(g_1, g_2))
-    g.add_edges(nodes_cross_edges(g_1, g_2))
+  def self.lexicographic_product(g1, g2)
+    g = init_product_graph(g1, g2)
+    g.add_nodes(node_product(g1, g2))
+    g.add_edges(edges_cross_nodes_and_nodes(g1, g2))
+    g.add_edges(nodes_cross_edges(g1, g2))
     g
   end
 
   # Returns the strong product of two graphs
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
+  # @param g1 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param g2 [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.2
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the strong product of the two graphs
-  def self.strong_product(g_1, g_2)
-    g = init_product_graph(g_1, g_2)
-    g.add_nodes(node_product(g_1, g_2))
-    g.add_edges(nodes_cross_edges(g_1, g_2))
-    g.add_edges(edges_cross_nodes(g_1, g_2))
-    g.add_edges(directed_edges_cross_edges(g_1, g_2))
-    g.add_edges(undirected_edges_cross_edges(g_1, g_2)) unless g.directed?
+  def self.strong_product(g1, g2)
+    g = init_product_graph(g1, g2)
+    g.add_nodes(node_product(g1, g2))
+    g.add_edges(nodes_cross_edges(g1, g2))
+    g.add_edges(edges_cross_nodes(g1, g2))
+    g.add_edges(directed_edges_cross_edges(g1, g2))
+    g.add_edges(undirected_edges_cross_edges(g1, g2)) unless g.directed?
     g
   end
 
-  # TODO: Reduce method complexity and method length
-
   # Returns the specified power of the graph
   #
-  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
-  # @param [Numeric] the power to which to raise the graph to
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param pow [Numeric] the power to which to raise the graph to
   #
   # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the power of the graph
   def self.power(graph, pow)
     raise ArgumentError, 'Power must be a positive quantity!' if pow <= 0
+
     result = NetworkX::Graph.new
     result.add_nodes(graph.nodes.map { |n, attrs| [n, attrs] })
     graph.nodes.each do |n, _attrs|
@@ -189,12 +184,14 @@ module NetworkX
         next_level = {}
         this_level.each do |v, _attrs|
           next if v == n
-          unless seen.key?(v)
+
+          unless seen.has_key?(v)
             seen[v] = level
             next_level.merge!(graph.adj[v])
           end
         end
         break if pow <= level
+
         level += 1
       end
       result.add_edges(seen.map { |v, _| [n, v] })

data/lib/networkx/operators/unary.rb

@@ -10,7 +10,7 @@ module NetworkX
 
     result.add_nodes(graph.nodes.map { |u, attrs| [u, attrs] })
     graph.adj.each do |u, u_edges|
-      graph.nodes.each { |v, attrs| result.add_edge(u, v, attrs) if !u_edges.key?(v) && u != v }
+      graph.nodes.each { |v, attrs| result.add_edge(u, v, **attrs) if !u_edges.has_key?(v) && u != v }
     end
     result
   end

data/lib/networkx/others/bridges.rb

@@ -0,0 +1,30 @@
+require_relative '../auxillary_functions/union_find'
+
+module NetworkX
+  # @return [[Object, Object]] bridges
+  #
+  # @param graph [Graph] Graph
+  def self.bridges(graph)
+    each_bridge(graph).to_a
+  end
+
+  # @param graph [Graph] Graph
+  def self.each_bridge(graph)
+    return enum_for(:each_bridge, graph) unless block_given?
+
+    graph.each_edge.with_index do |(s_i, t_i), i|
+      uf = UnionFind.new(1..graph.number_of_nodes)
+      graph.each_edge.with_index do |(s_j, t_j), j|
+        uf.unite(s_j, t_j) if i != j
+      end
+      yield [s_i, t_i] unless uf.same?(s_i, t_i)
+    end
+  end
+
+  # @return [Integer] the number of bridges
+  #
+  # @param graph [Graph] Graph
+  def self.number_of_bridges(graph)
+    bridges(graph).size
+  end
+end