networkx 0.1.0 → 0.1.1

data/lib/networkx/auxillary_functions/eccentricity.rb

@@ -0,0 +1,36 @@
+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
+  # TODO: Reduce method complexity and method length
+
+  # 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,35 @@
+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
+
+  # TODO: Reduce method complexity and method length
+
+  # 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,24 @@
+module NetworkX
+  class UnionFind
+    def initialize(nodes)
+      @unions = {}
+      nodes.each_with_index do |node, index|
+        @unions[node] = index
+      end
+    end
+
+    def connected?(node_1, node_2)
+      @unions[node_1] == @unions[node_2]
+    end
+
+    def union(node_1, node_2)
+      return if connected?(node_1, node_2)
+      node1_id = @unions[node_1]
+      node2_id = @unions[node_2]
+
+      @unions.each do |node, id|
+        @unions[node] = node1_id if id == node2_id
+      end
+    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
+    Hash[total].each { |_, distances| Hash[distances].each { |_, val| wiener_ind += val } }
+    graph.directed? ? wiener_ind : wiener_ind / 2
+  end
+end

data/lib/networkx/converters/to_csv.rb

@@ -0,0 +1,47 @@
+module NetworkX
+  # TODO: Reduce method length and method complexity
+
+  # 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,39 @@
+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
+
+  # TODO: Reduce method length
+
+  # 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,228 @@
+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, :nodes, :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 node_1 [Object] the first node of the edge
+    # @param node_2 [Object] the second node of the edge
+    # @param edge_attrs [Hash{ Object => Object }] the hash of the edge attributes
+    def add_edge(node_1, node_2, **edge_attrs)
+      add_node(node_1)
+      add_node(node_2)
+
+      edge_attrs = (@adj[node_1][node_2] || {}).merge(edge_attrs)
+      @adj[node_1][node_2] = edge_attrs
+      @pred[node_2][node_1] = 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.key?(node)
+    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.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 node_1 [Object] the first node of the edge
+    # @param node_2 [Object] the second node of the edge
+    def remove_edge(node_1, node_2)
+      raise KeyError, "#{node_1} is not a valid node." unless @nodes.key?(node_1)
+      raise KeyError, "#{node_2} is not a valid node" unless @nodes.key?(node_2)
+      raise KeyError, 'The given edge is not a valid one.' unless @adj[node_1].key?(node_2)
+
+      @adj[node_1].delete(node_2)
+      @pred[node_2].delete(node_1)
+    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).inject(:+)
+    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.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
+
+    # TODO: Reduce method complexity and method length
+
+    # 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].key?(v) && nodes.include?(v)
+          end
+          return sub_graph
+        end
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of nodes, '\
+                            "received #{nodes.class.name} instead."
+      end
+    end
+
+    # TODO: Reduce method complexity and method length
+
+    # 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.key?(u)\
+                                                                                    && @adj[u].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
+        return sub_graph
+      else
+        raise ArgumentError, 'Expected Argument to be Array or Set of edges, '\
+        "received #{edges.class.name} instead."
+      end
+    end
+  end
+end