networkx 0.1.0 → 0.2.0

data/lib/networkx/auxillary_functions/dag.rb

@@ -0,0 +1,59 @@
+module NetworkX
+  # Returns the descendants of a given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] node to find descendents of
+  #
+  # @return [Array<Object>] Array of the descendants
+  def self.descendants(graph, source)
+    raise ArgumentError, 'Source is not present in the graph!' unless graph.node?(source)
+
+    des = single_source_shortest_path_length(graph, source).map { |u, _| u }.uniq
+    des - [source]
+  end
+
+  # Returns the ancestors of a given node
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param source [Object] node to find ancestors of
+  #
+  # @return [Array<Object>] Array of the ancestors
+  def self.ancestors(graph, source)
+    raise ArgumentError, 'Source is not present in the graph!' unless graph.node?(source)
+
+    anc = single_source_shortest_path_length(graph.reverse, source).map { |u, _| u }.uniq
+    anc - [source]
+  end
+
+  # Returns the nodes arranged in the topologically sorted fashion
+  #
+  # @param graph [DiGraph] a graph
+  #
+  # @return [Array<Object>] Array of the nodes
+  def self.topological_sort(graph)
+    raise ArgumentError, 'Topological Sort not defined on undirected graphs!' unless graph.directed?
+
+    nodes = []
+    indegree_map = graph.nodes.each_key.map do |u|
+      [u, graph.in_degree(u)] if graph.in_degree(u).positive?
+    end.compact.to_h
+    zero_indegree = graph.nodes.each_key.select { |u| graph.in_degree(u).zero? }
+
+    until zero_indegree.empty?
+      node = zero_indegree.shift
+      raise ArgumentError, 'Graph changed during iteration!' unless graph.nodes.has_key?(node)
+
+      graph.adj[node].each_key do |child|
+        indegree_map[child] -= 1
+        if indegree_map[child].zero?
+          zero_indegree << child
+          indegree_map.delete(child)
+        end
+      end
+      nodes << node
+    end
+    raise ArgumentError, 'Graph contains cycle or graph changed during iteration!' unless indegree_map.empty?
+
+    nodes
+  end
+end

data/lib/networkx/auxillary_functions/eccentricity.rb

@@ -0,0 +1,37 @@
+module NetworkX
+  # Returns the eccentricity of a particular node or all nodes
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param node [Object] node to find the eccentricity of
+  #
+  # @return [Array<Numeric>, Numeric] eccentricity/eccentricites of all nodes
+  def self.eccentricity(graph, node = nil)
+    e = {}
+    graph.nodes.each do |u, _|
+      length = single_source_shortest_path_length(graph, u)
+      l = length.length
+      raise ArgumentError, 'Found infinite path length!' unless l == graph.nodes.length
+
+      e[u] = length.max_by { |a| a[1] }[1]
+    end
+    node.nil? ? e : e[node]
+  end
+
+  # Returns the diameter of a graph
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Numeric] diameter of the graph
+  def self.diameter(graph)
+    eccentricity(graph).values.max
+  end
+
+  # Returns the radius of a graph
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [Numeric] radius of the graph
+  def self.radius(graph)
+    eccentricity(graph).values.min
+  end
+end

data/lib/networkx/auxillary_functions/mis.rb

@@ -0,0 +1,23 @@
+module NetworkX
+  # Returns the maximal independent set of a graph
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param nodes [Object] nodes to be considered in the MIS
+  #
+  # @return [Numeric] radius of the graph
+  def self.maximal_independent_set(graph, nodes)
+    raise 'The array containing the nodes should be a subset of the graph!' if (graph.nodes.keys - nodes).empty?
+
+    neighbours = []
+    nodes.each { |u| graph.adj[u].each { |v, _| neighbours |= [v] } }
+    raise 'Nodes is not an independent set of graph!' if (neighbours - nodes).empty?
+
+    available_nodes = graph.nodes.keys - (neighbours | nodes)
+    until available_nodes.empty?
+      node = available_nodes.sample
+      nodes << node
+      available_nodes -= (graph.adj[node].keys + [node])
+    end
+    nodes
+  end
+end

data/lib/networkx/auxillary_functions/mst.rb

@@ -0,0 +1,33 @@
+module NetworkX
+  # Helper function for the minimum spanning tree
+  #
+  def self.get_edges_weights(graph)
+    edges = []
+    graph.adj.each do |u, u_edges|
+      u_edges.each do |v, uv_attrs|
+        edges << [[u, v], uv_attrs[:weight] || Float::INFINITY]
+      end
+    end
+    edges
+  end
+
+  # Returns the minimum spanning tree of a graph
+  #
+  # @param graph [Graph, DiGraph] a graph
+  #
+  # @return [DiGraph, Graph] a minimum spanning tree of the graph
+  def self.minimum_spanning_tree(graph)
+    mst = Marshal.load(Marshal.dump(graph))
+    mst.clear
+    edges = get_edges_weights(graph).sort_by { |a| a[1] }
+    union_find = UnionFind.new(graph.nodes.keys)
+    while edges.any? && mst.nodes.length <= graph.nodes.length
+      edge = edges.shift
+      unless union_find.connected?(edge[0][0], edge[0][1])
+        union_find.union(edge[0][0], edge[0][1])
+        mst.add_edge(edge[0][0], edge[0][1], **graph.adj[edge[0][0]][edge[0][1]])
+      end
+    end
+    mst
+  end
+end

data/lib/networkx/auxillary_functions/union_find.rb

@@ -0,0 +1,104 @@
+module NetworkX
+  # Union Find Tree
+  #
+  # Reference
+  # - [ac-library-rb DSU (CC0)](https://github.com/universato/ac-library-rb/blob/main/lib/dsu.rb)
+  # - [Python NetworkX UnionFind](https://networkx.org/documentation/stable/_modules/networkx/utils/union_find.html)
+  #
+  #
+  # @attr_reader parents [Hash{ Object => Object }] Return parent of each element
+  # @attr_reader weights [Hash{ Object => Integer }] Return weight of each element
+  class UnionFind
+    attr_accessor :parents, :weights
+
+    # Constructor for initializing Union Find Tree
+    #
+    # @param nodes [?Array[Object]] nodes
+    #
+    # @return [UnionFind] Union Find Tree
+    def initialize(nodes = nil)
+      @weights = {}
+      @parents = {}
+      nodes&.each do |node|
+        @weights[node] = 1
+        @parents[node] = node
+      end
+    end
+
+    # Return the root of node
+    #
+    # @param node [Object] node
+    #
+    # @return [Object] root of node, leader of node
+    def [](node)
+      if @parents.has_key?(node)
+        @parents[node] == node ? node : (@parents[node] = self[@parents[node]])
+      else
+        @weights[node] = 1
+        @parents[node] = node
+      end
+    end
+
+    # Return the root of node
+    #
+    # @param node [Object] node
+    #
+    # @return [Object] root of node, leader of node
+    def root(node)
+      @parents.has_key?(node) or raise ArgumentError.new, "#{node} is not a node"
+
+      @parents[node] == node ? node : (@parents[node] = root(@parents[node]))
+    end
+
+    def each(&block)
+      @parents.each_key(&block)
+    end
+
+    def to_sets
+      each.group_by { |node| root(node) }.values
+    end
+    alias groups to_sets
+
+    # Is each root of two nodes the same?
+    #
+    # @param node1 [Object] node
+    # @param node2 [Object] node
+    #
+    # @return [bool] Is each root of node1 and nodes_2 the same?
+    def connected?(node1, node2)
+      root(node1) == root(node2)
+    end
+    alias same? connected?
+
+    # Unite nodes.
+    #
+    # @param nodes [Array[Object]] nodes
+    #
+    # @return [Object | nil] root of united nodes
+    def union(*nodes)
+      return merge(*nodes) if nodes.size == 2
+
+      roots = nodes.map { |node| self[node] }.uniq
+      return if roots.size == 1
+
+      roots.sort_by! { |root| @weights[root] }
+      root = roots[-1]
+      roots[0...-1].each do |r|
+        @weights[root] += @weights[r]
+        @parents[r] = root
+      end
+      root
+    end
+    alias unite union
+
+    def merge(node1, node2)
+      x = self[node1]
+      y = self[node2]
+      return if x == y
+
+      x, y = y, x if @weights[x] < @weights[y]
+      @weights[x] += @weights[y]
+      @parents[y] = x
+    end
+  end
+end

data/lib/networkx/auxillary_functions/vitality.rb

@@ -0,0 +1,13 @@
+module NetworkX
+  # Returns the closeness vitality of a node
+  #
+  # @param graph [Graph, DiGraph] a graph
+  # @param node [Object] node to compute closeness vitality of
+  #
+  # @return [Numeric] closeness vitality of the given node
+  def self.closeness_vitality(graph, node)
+    before = wiener_index(graph)
+    after = wiener_index(graph.subgraph(graph.nodes.keys - [node]))
+    before - after
+  end
+end

data/lib/networkx/auxillary_functions/wiener.rb

@@ -0,0 +1,13 @@
+module NetworkX
+  # Returns the wiener index of the graph
+  #
+  # @param graph [Graph, DiGraph] a graph
+  #
+  # @return [Numeric] wiener index of the graph
+  def self.wiener_index(graph)
+    total = all_pairs_shortest_path_length(graph)
+    wiener_ind = 0
+    total.to_h.each { |_, distances| distances.to_h.each { |_, val| wiener_ind += val } }
+    graph.directed? ? wiener_ind : wiener_ind / 2
+  end
+end

data/lib/networkx/converters/to_csv.rb

@@ -0,0 +1,45 @@
+module NetworkX
+  # Saves the graph in a csv file
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  # @param filename [String] filename of the graph
+  def self.graph_to_csv(graph, filename = 'graph.csv')
+    CSV.open(filename, 'wb') do |csv|
+      csv << [graph.class.name]
+      csv << ['graph_values']
+      csv << graph.graph.keys
+      csv << graph.graph.values
+      csv << ['graph_nodes']
+      graph.nodes.each do |u, attrs|
+        node_attrs = [u]
+        attrs.each do |k, v|
+          node_attrs << k
+          node_attrs << v
+        end
+        csv << node_attrs
+      end
+      csv << ['graph_edges']
+      graph.adj.each do |u, u_edges|
+        u_edges.each do |v, uv_attrs|
+          if graph.multigraph?
+            uv_attrs.each do |key, attrs|
+              node_attrs = [u, v, key]
+              attrs.each do |k, k_attrs|
+                node_attrs << k
+                node_attrs << k_attrs
+              end
+              csv << node_attrs
+            end
+          else
+            node_attrs = [u, v]
+            uv_attrs.each do |k, vals|
+              node_attrs << k
+              node_attrs << vals
+            end
+            csv << node_attrs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/networkx/converters/to_json.rb

@@ -0,0 +1,37 @@
+module NetworkX
+  # Returns a JSON object of the given graph
+  #
+  # @param graph [Graph, DiGraph, MultiGraph, MultiDiGraph] a graph
+  #
+  # @return [JSON] json encoded graph
+  def self.graph_to_json(graph)
+    json_hash = {}
+    json_hash[:class] = graph.class.name
+    json_hash[:graph] = graph.graph
+    json_hash[:nodes] = graph.nodes
+    json_hash[:adj] = graph.adj
+    json_hash.to_json
+  end
+
+  # Returns a graph from the json encoded graph
+  #
+  # @param json_str [JSON] json encoded string
+  #
+  # @return [Graph, DiGraph, MultiGraph, MultiDiGraph] a decoded graph
+  def self.json_to_graph(json_str)
+    graph_hash = JSON.parse(json_str)
+    case json_str['class']
+    when 'NetworkX::Graph'
+      graph = NetworkX::Graph.new(graph_hash.graph)
+    when 'NetworkX::MultiGraph'
+      graph = NetworkX::MultiGraph.new(graph_hash.graph)
+    when 'NetworkX::DiGraph'
+      graph = NetworkX::DiGraph.new(graph_hash.graph)
+    when 'NetworkX::MultiDiGraph'
+      graph = NetworkX::MultiDiGraph.new(graph_hash.graph)
+    end
+    graph.adj = graph_hash['adj']
+    graph.nodes = graph_hash['nodes']
+    graph
+  end
+end

data/lib/networkx/digraph.rb

@@ -0,0 +1,234 @@
+module NetworkX
+  # Describes the class for making Directed Graphs
+  #
+  # @attr_reader adj [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
+  #                  Stores the edges and their attributes in an adjencency list form
+  # @attr_reader pred [Hash{ Object => Hash{ Object => Hash{ Object => Object } } }]
+  #                  Stores the reverse edges and their attributes in an adjencency list form
+  # @attr_reader nodes [Hash{ Object => Hash{ Object => Object } }] Stores the nodes and their attributes
+  # @attr_reader graph [Hash{ Object => Object }] Stores the attributes of the graph
+  class DiGraph < Graph
+    attr_reader :adj, :graph, :pred
+
+    # Constructor for initializing graph
+    #
+    # @example Initialize a graph with attributes 'type' and 'name'
+    #   graph = NetworkX::Graph.new(name: "Social Network", type: "undirected")
+    #
+    # @param graph_attrs [Hash{ Object => Object }] the graph attributes in a hash format
+    def initialize(**graph_attrs)
+      super(**graph_attrs)
+
+      @pred = {}
+    end
+
+    # Adds the respective edge
+    #
+    # @example Add an edge with attribute name
+    #   graph.add_edge(node1, node2, name: "Edge1")
+    #
+    # @example Add an edge with no attribute
+    #   graph.add_edge("Bangalore", "Chennai")
+    #
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
+    def add_edge(node1, node2, **edge_attrs)
+      add_node(node1)
+      add_node(node2)
+
+      edge_attrs = (@adj[node1][node2] || {}).merge(edge_attrs)
+      @adj[node1][node2] = edge_attrs
+      @pred[node2][node1] = edge_attrs
+    end
+
+    # Adds a node and its attributes to the graph
+    #
+    # @example Add a node with attribute 'type'
+    #   graph.add_node("Noida", type: "city")
+    #
+    # @param node [Object] the node object
+    # @param node_attrs [Hash{ Object => Object }] the hash of the attributes of the node
+    def add_node(node, **node_attrs)
+      super(node, **node_attrs)
+
+      @pred[node] = {} unless @pred.has_key?(node)
+    end
+
+    def nodes(data: true)
+      data ? @nodes : @nodes.keys
+    end
+
+    # Removes node from the graph
+    #
+    # @example
+    #   graph.remove_node("Noida")
+    #
+    # @param node [Object] the node to be removed
+    def remove_node(node)
+      raise KeyError, "Error in deleting node #{node} from Graph." unless @nodes.has_key?(node)
+
+      neighbours = @adj[node]
+      neighbours.each_key { |k| @pred[k].delete(node) }
+      @pred[node].each_key do |k|
+        @adj[k].delete(node)
+      end
+
+      @pred.delete(node)
+      @adj.delete(node)
+      @nodes.delete(node)
+    end
+
+    # Removes edge from the graph
+    #
+    # @example
+    #   graph.remove_edge('Noida', 'Bangalore')
+    #
+    # @param node1 [Object] the first node of the edge
+    # @param node2 [Object] the second node of the edge
+    def remove_edge(node1, node2)
+      raise KeyError, "#{node1} is not a valid node." unless @nodes.has_key?(node1)
+      raise KeyError, "#{node2} is not a valid node" unless @nodes.has_key?(node2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node1].has_key?(node2)
+
+      @adj[node1].delete(node2)
+      @pred[node2].delete(node1)
+    end
+
+    # Clears the graph
+    #
+    # @example
+    #   graph.clear
+    def clear
+      super
+
+      @pred.clear
+    end
+
+    # Returns number of edges
+    #
+    # @example
+    #   graph.number_of_edges
+    def number_of_edges
+      @adj.values.map(&:length).sum
+    end
+
+    # Returns the size of graph
+    #
+    # @example
+    #   graph.size(true)
+    #
+    # @param is_weighted [Bool] if true, method returns sum of weights of all edges
+    #                            else returns number of edges
+    def size(is_weighted = false)
+      if is_weighted
+        graph_size = 0
+        @adj.each do |_, hash_val|
+          hash_val.each { |_, v| graph_size += v[:weight] if v.has_key?(:weight) }
+        end
+        return graph_size
+      end
+      number_of_edges
+    end
+
+    # Returns in-degree of a given node
+    #
+    # @example
+    #   graph.in_degree(node)
+    #
+    # @param node [Object] the node whose in degree is to be calculated
+    def in_degree(node)
+      @pred[node].length
+    end
+
+    # Returns out-degree of a given node
+    #
+    # @example
+    #   graph.out_degree(node)
+    #
+    # @param node [Object] the node whose out degree is to be calculated
+    def out_degree(node)
+      @adj[node].length
+    end
+
+    # Returns the reversed version of the graph
+    #
+    # @example
+    #   graph.reverse
+    def reverse
+      new_graph = NetworkX::DiGraph.new(**@graph)
+      @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
+      @adj.each do |u, edges|
+        edges.each { |v, attrs| new_graph.add_edge(v, u, **attrs) }
+      end
+      new_graph
+    end
+
+    # Returns the undirected version of the graph
+    #
+    # @example
+    #   graph.to_undirected
+    def to_undirected
+      new_graph = NetworkX::Graph.new(**@graph)
+      @nodes.each { |u, attrs| new_graph.add_node(u, **attrs) }
+      @adj.each do |u, edges|
+        edges.each { |v, attrs| new_graph.add_edge(u, v, **attrs) }
+      end
+      new_graph
+    end
+
+    # Returns subgraph consisting of given array of nodes
+    #
+    # @example
+    #   graph.subgraph(%w[Mumbai Nagpur])
+    #
+    # @param nodes [Array<Object>] the nodes to be included in the subgraph
+    def subgraph(nodes)
+      case nodes
+      when Array, Set
+        sub_graph = NetworkX::DiGraph.new(**@graph)
+        nodes.each do |u|
+          raise KeyError, "#{u} does not exist in the current graph!" unless node?(u)
+
+          sub_graph.add_node(u, **@nodes[u])
+          @adj[u].each do |v, uv_attrs|
+            sub_graph.add_edge(u, v, **uv_attrs) if @adj[u].has_key?(v) && nodes.include?(v)
+          end
+        end
+        sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, ' \
+                             "received #{nodes.class.name} instead."
+      end
+    end
+
+    # Returns subgraph consisting of given edges
+    #
+    # @example
+    #   graph.edge_subgraph([%w[Nagpur Wardha], %w[Nagpur Mumbai]])
+    #
+    # @param edges [Array<Object, Object>] the edges to be included in the subraph
+    def edge_subgraph(edges)
+      case edges
+      when Array, Set
+        sub_graph = NetworkX::DiGraph.new(**@graph)
+        edges.each do |u, v|
+          raise KeyError, "Edge between #{u} and #{v} does not exist in the graph!" unless @nodes.has_key?(u) \
+                                                                                    && @adj[u].has_key?(v)
+
+          sub_graph.add_node(u, **@nodes[u])
+          sub_graph.add_node(v, **@nodes[v])
+          sub_graph.add_edge(u, v, **@adj[u][v])
+        end
+        sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, ' \
+                             "received #{edges.class.name} instead."
+      end
+    end
+
+    def directed?
+      true
+    end
+  end
+end