networkx 0.1.0 → 0.2.0

data/lib/networkx/operators/binary.rb

@@ -0,0 +1,222 @@
+module NetworkX
+  # Returns the edges of the graph in an array
+  def self.get_edges(graph)
+    edges = []
+    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
+
+  # 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 = graph.class.new
+
+    idx_dict = graph.nodes.keys.to_h 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
+
+  # Performs the intersection of two graphs
+  #
+  # @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(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
+
+  # Performs the difference of two graphs
+  #
+  # @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(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.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) unless g2.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
+        end
+      end
+    end
+    result
+  end
+
+  # Performs the symmetric difference of two graphs
+  #
+  # @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(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.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) unless g2.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, **uv_attrs) unless g2.edge?(u, v)
+        end
+      end
+    end
+
+    g2.adj.each do |u, u_edges|
+      u_edges.each do |v, uv_attrs|
+        next if u > v && g1.instance_of?(MultiGraph)
+
+        if g2.multigraph?
+          uv_attrs.each do |k, attrs|
+            result.add_edge(u, v, **attrs) unless g1.edge?(u, v, k)
+          end
+        else
+          result.add_edge(u, v, **uv_attrs) unless g1.edge?(u, v)
+        end
+      end
+    end
+    result
+  end
+
+  # Performs the composition of two graphs
+  #
+  # @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(g1, g2)
+    result = g1.class.new
+
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
+
+    result.add_nodes(g1.nodes.map { |u, attrs| [u, attrs] })
+    result.add_nodes(g2.nodes.map { |u, attrs| [u, 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
+      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
+
+  # Performs the union of two graphs
+  #
+  # @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(g1, g2)
+    raise ArgumentError, 'Arguments must be both Graphs or MultiGraphs!' unless g1.multigraph? == g2.multigraph?
+
+    new_graph = g1.class.new
+    new_graph.graph.merge!(g1.graph)
+    new_graph.graph.merge!(g2.graph)
+
+    raise ArgumentError, 'Graphs must be disjoint!' unless (g1.nodes.keys & g2.nodes.keys).empty?
+
+    g1_edges = get_edges(g1)
+    g2_edges = get_edges(g2)
+
+    new_graph.add_nodes(g1.nodes.keys)
+    new_graph.add_edges(g1_edges)
+    new_graph.add_nodes(g2.nodes.keys)
+    new_graph.add_edges(g2_edges)
+
+    new_graph
+  end
+
+  # Performs the disjoint union of two graphs
+  #
+  # @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(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

@@ -0,0 +1,201 @@
+module NetworkX
+  # 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(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(g1, g2)
+    n_product = []
+    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(g1, g2)
+    result = []
+    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
+    result
+  end
+
+  # Returns the product of undirected edges with edges
+  def self.undirected_edges_cross_edges(g1, g2)
+    result = []
+    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
+    result
+  end
+
+  # Returns the product of edges with edges
+  def self.edges_cross_nodes(g1, g2)
+    result = []
+    edges_in_array(g1).each do |u, v, d|
+      g2.nodes.each_key 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(g1, g2)
+    result = []
+    g1.nodes.each_key do |x|
+      edges_in_array(g2).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(g1, g2)
+    result = []
+    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
+    end
+    result
+  end
+
+  # Initializes the product graph
+  def self.init_product_graph(g1, g2)
+    raise ArgumentError, 'Arguments must be both directed or undirected!' unless g1.directed? == g2.directed?
+
+    g = if g1.multigraph? || g2.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 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(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 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(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 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(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 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(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
+
+  # Returns the specified power of the graph
+  #
+  # @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|
+      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.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] })
+    end
+    result
+  end
+end

data/lib/networkx/operators/unary.rb

@@ -0,0 +1,17 @@
+module NetworkX
+  # Performs the complement operation on the graph
+  #
+  # @param [Graph, DiGraph, MultiGraph, MultiDiGraph] graph
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] the complement of the graph
+  def self.complement(graph)
+    result = Marshal.load(Marshal.dump(graph))
+    result.clear
+
+    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.has_key?(v) && u != v }
+    end
+    result
+  end
+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

data/lib/networkx/others/generators.rb

@@ -0,0 +1,237 @@
+require_relative '../../networkx'
+
+module NetworkX
+  class Graph
+    # private class method
+    def self.complete_edges(n)
+      n = (0...n) if n.is_a?(Integer)
+
+      edges = []
+      n.each do |i|
+        n.each do |j|
+          edges << [i, j] if i < j
+        end
+      end
+      edges
+    end
+
+    def self.balanced_tree(r, h)
+      edges = []
+      q = [0]
+      i = 0
+      h.times do
+        t = q.dup
+        q.clear
+        t.each do |v|
+          r.times do
+            i += 1
+            edges << [v, i]
+            q << i
+          end
+        end
+      end
+      graph = new(name: "balanced_tree(#{r}, #{h})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.barbell_graph(m1, m2)
+      edges = complete_edges(m1)
+      edges.concat((m1..m2 + m1).map { |k| [k - 1, k] })
+      edges.concat complete_edges(m1 + m2...m1 + m2 + m1)
+
+      graph = new(name: "barbell_graph(#{m1}, #{m2})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.complete_graph(n)
+      n = (0...n) if n.is_a?(Integer)
+
+      edges = []
+      n.each do |i|
+        n.each do |j|
+          edges << [i, j] if i < j
+        end
+      end
+
+      graph = new(name: "complete_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.circular_ladder_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+      edges << [n - 1, 0]
+      edges.concat((n...2 * n - 1).map { |v| [v, v + 1] })
+      edges << [2 * n - 1, n]
+      edges.concat((0...n).map { |v| [v, v + n] })
+
+      graph = new(name: "circular_ladder_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.cycle_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+      edges << [n - 1, 0]
+
+      graph = new(name: "cycle_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.empty_graph(number_of_nodes)
+      empty_graph = new(name: "empty_graph#{number_of_nodes}")
+      empty_graph.add_nodes_from(0...number_of_nodes)
+      empty_graph
+    end
+
+    def self.ladder_graph(n)
+      edges = (0...n - 1).map { |k| [k, k + 1] }
+      edges.concat((n...2 * n - 1).map { |k| [k, k + 1] })
+      edges.concat((0...n).map { |k| [k, k + n] })
+
+      graph = new(name: "ladder_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.lollipop_graph(m, n)
+      edges = complete_edges(m)
+      edges.concat((m - 1...m - 1 + n).map { |v| [v, v + 1] })
+
+      graph = new(name: "lollipop_graph(#{m}, #{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.null_graph
+      new(name: 'null_graph')
+    end
+
+    def self.path_graph(n)
+      edges = (0...n - 1).map { |v| [v, v + 1] }
+
+      graph = new(name: "path_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.star_graph(n)
+      edges = (1..n).map { |i| [0, i] }
+
+      graph = new(name: "star_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.trivial_graph
+      trivial_graph = new(name: 'trivial_grpph')
+      trivial_graph.add_node(0)
+      trivial_graph
+    end
+
+    def self.wheel_graph(n)
+      edges = (1..n - 1).map { |i| [0, i] }
+      edges.concat((1...n - 1).map { |i| [i, i + 1] })
+      edges << [1, n - 1]
+
+      graph = new(name: "wheel_graph(#{n})")
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.bull_graph
+      edges = [[0, 1], [1, 2], [2, 0], [1, 3], [2, 4]]
+      graph = new(name: 'bull_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.cubical_graph
+      graph = circular_ladder_graph(4)
+      graph.graph[:name] = 'cubical_graph'
+      graph
+    end
+
+    def self.diamond_graph
+      edges = [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3]]
+      graph = new(name: 'diamond_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    # 12
+    def self.dodecahedral_graph
+      edges = (0...19).map { |k| [k, k + 1] }
+      edges.concat [[0, 19], [0, 10], [1, 8], [2, 6], [3, 19], [4, 17], [5, 15], [7, 14], [9, 13], [11, 18], [12, 16]]
+      graph = new(name: 'dodecahedral_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.heawood_graph
+      edges = (0...13).map { |k| [k, k + 1] }
+      edges << [13, 0]
+      edges.concat [[0, 5], [1, 10], [2, 7], [3, 12], [4, 9], [6, 11], [8, 13]]
+      graph = new(name: 'heawood_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.house_graph
+      edges = [[0, 1], [0, 2], [1, 3], [2, 3], [2, 4], [3, 4]]
+      graph = new(name: 'house_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.house_x_graph
+      edges = (0...4).map { |k| [k, k + 1] }
+      edges.concat [[0, 2], [0, 3], [1, 3], [2, 4], [3, 4]]
+      graph = new(name: 'house_x_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.moebius_kantor_graph
+      edges = (0...15).map { |k| [k, k + 1] }
+      edges << [15, 0]
+      edges.concat [[0, 5], [1, 12], [2, 7], [4, 9], [3, 14], [6, 11], [8, 13], [10, 15]]
+      graph = new(name: 'moebius_kantor_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    # 8: 6 nodes, 12 edges
+    def self.octahedral_graph
+      edges = []
+      6.times do |i|
+        6.times do |j|
+          edges << [i, j] if i != j && i + j != 5
+        end
+      end
+      graph = new(name: 'octahedral_graph')
+      graph.add_edges(edges)
+      graph
+    end
+
+    def self.tetrahedral_graph
+      graph = complete_graph(4)
+      graph.graph[:name] = 'tetrahedral_graph'
+      graph
+    end
+
+    # Experimental For debug.
+    #
+    # @return data for https://hello-world-494ec.firebaseapp.com/
+    def put_graph_x2
+      output = <<~"OUTPUT"
+        #{number_of_nodes} #{number_of_edges}
+        #{edges.map { |edge| edge.join(' ') }.join("\n")}
+      OUTPUT
+      puts output
+    end
+  end
+end