networkx 0.1.0 → 0.1.1

data/lib/networkx/operators/all.rb

@@ -0,0 +1,61 @@
+module NetworkX
+  # Performs the union of many graphs
+  #
+  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] union of all the graphs
+  def self.union_all(graphs)
+    raise ArgumentError, 'Argument array is empty' if graphs.empty?
+    result = graphs.shift
+
+    graphs.each do |graph|
+      result = NetworkX.union(result, graph)
+    end
+    result
+  end
+
+  # Performs the disjoint union of many graphs
+  #
+  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] disjoint union of all the graphs
+  def self.disjoint_union_all(graphs)
+    raise ArgumentError, 'Argument array is empty' if graphs.empty?
+    result = graphs.shift
+
+    graphs.each do |graph|
+      result = NetworkX.disjoint_union(result, graph)
+    end
+    result
+  end
+
+  # Performs the intersection of many graphs
+  #
+  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] intersection of all the graphs
+  def self.intersection_all(graphs)
+    raise ArgumentError, 'Argument array is empty' if graphs.empty?
+    result = graphs.shift
+
+    graphs.each do |graph|
+      result = NetworkX.intersection(result, graph)
+    end
+    result
+  end
+
+  # Performs the composition of many graphs
+  #
+  # @param [Array<Graph>, Array<DiGraph>, Array<MultiGraph>, Array<MultiDiGraph>] Array of graphs
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] composition of all the graphs
+  def self.compose_all(graphs)
+    raise ArgumentError, 'Argument array is empty' if graphs.empty?
+    result = graphs.shift
+
+    graphs.each do |graph|
+      result = NetworkX.compose(result, graph)
+    end
+    result
+  end
+end

data/lib/networkx/operators/binary.rb

@@ -0,0 +1,244 @@
+# 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]
+      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
+
+    idx_dict = Hash[graph.nodes.keys.map do |v|
+      starting_int += 1
+      [v, starting_int]
+    end]
+
+    graph.nodes.each do |u, 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)
+          end
+        else
+          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
+  #
+  # @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)
+          end
+        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
+  #
+  # @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
+
+    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) }
+
+    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) unless g_2.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, uv_attrs) unless g_2.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
+  #
+  # @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
+
+    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) }
+
+    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) unless g_2.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, uv_attrs) unless g_2.edge?(u, v)
+        end
+      end
+    end
+
+    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) unless g_1.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, uv_attrs) unless g_1.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
+  #
+  # @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
+
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g_1.multigraph? == g_2.multigraph?
+
+    result.add_nodes(g_1.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(g_2.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) } } }
+    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) } }
+    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
+  #
+  # @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
+
+    new_graph.graph.merge!(g_1.graph)
+    new_graph.graph.merge!(g_2.graph)
+
+    raise ArgumentError, 'Graphs must be disjoint!' unless (g_1.nodes.keys & g_2.nodes.keys).empty?
+
+    g1_edges = get_edges(g_1)
+    g2_edges = get_edges(g_2)
+
+    new_graph.add_nodes(g_1.nodes.keys)
+    new_graph.add_edges(g1_edges)
+    new_graph.add_nodes(g_2.nodes.keys)
+    new_graph.add_edges(g2_edges)
+
+    new_graph
+  end
+
+  # Performs the disjoint union of two graphs
+  #
+  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param [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)
+    result
+  end
+end

data/lib/networkx/operators/product.rb

@@ -0,0 +1,204 @@
+# 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 = []
+    if graph.multigraph?
+      graph.adj.each do |u, u_edges|
+        u_edges.each do |v, uv_edges|
+          uv_edges.each do |_k, attrs|
+            edge_array << [u, v, attrs]
+          end
+        end
+      end
+    else
+      graph.adj.each do |u, u_edges|
+        u_edges.each do |v, attrs|
+          edge_array << [u, v, attrs]
+        end
+      end
+    end
+    edge_array
+  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]]] }]
+  end
+
+  # Returns the node product of nodes of two graphs
+  def self.node_product(g_1, g_2)
+    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)]
+      end
+    end
+    n_product
+  end
+
+  # Returns the product of directed edges with edges
+  def self.directed_edges_cross_edges(g_1, g_2)
+    result = []
+    edges_in_array(g_1).each do |u, v, c|
+      edges_in_array(g_2) do |x, y, d|
+        result << [[u, x], [v, y], hash_product(c, d)]
+      end
+    end
+    result
+  end
+
+  # Returns the product of undirected edges with edges
+  def self.undirected_edges_cross_edges(g_1, g_2)
+    result = []
+    edges_in_array(g_1).each do |u, v, c|
+      edges_in_array(g_2).each do |x, y, d|
+        result << [[v, x], [u, y], hash_product(c, d)]
+      end
+    end
+    result
+  end
+
+  # Returns the product of edges with edges
+  def self.edges_cross_nodes(g_1, g_2)
+    result = []
+    edges_in_array(g_1).each do |u, v, d|
+      g_2.nodes.keys.each do |x|
+        result << [[u, x], [v, x], d]
+      end
+    end
+    result
+  end
+
+  # Returns the product of directed nodes with edges
+  def self.nodes_cross_edges(g_1, g_2)
+    result = []
+    g_1.nodes.keys.each do |x|
+      edges_in_array(g_2).each do |u, v, d|
+        result << [[x, u], [x, v], d]
+      end
+    end
+    result
+  end
+
+  # Returns the product of edges with pairs of nodes
+  def self.edges_cross_nodes_and_nodes(g_1, g_2)
+    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|
+          result << [[u, x], [v, y], d]
+        end
+      end
+    end
+    result
+  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?
+
+    g = if g_1.multigraph? || g_2.multigraph?
+          NetworkX::MultiGraph.new
+        else
+          NetworkX::Graph.new
+        end
+    g = g.to_directed if g.directed?
+    g
+  end
+
+  # Returns the tensor product of two graphs
+  #
+  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph no.1
+  # @param [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?
+    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
+  #
+  # @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))
+    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
+  #
+  # @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))
+    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
+  #
+  # @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?
+    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
+  #
+  # @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|
+      seen = {}
+      level = 1
+      next_level = graph.adj[n]
+      until next_level.empty?
+        this_level = next_level
+        next_level = {}
+        this_level.each do |v, _attrs|
+          next if v == n
+          unless seen.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] })
+    end
+    result
+  end
+end