networkr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 43e672ad355d6a2b7535dcea503b62266cc29d8c
+  data.tar.gz: 054fb810a76cc380e31f6c51a184d798538106d5
+SHA512:
+  metadata.gz: 3f623b282a654a2ec6b18d4e8ab4cf2e05c2839c82c48da0e830ddfbc0cc8c2ad5c916ad609fd5835a189364df528e5f0a558e4e2d463681fcc6565c14193795
+  data.tar.gz: f9dbe521e03f73414c12b03fc7d7ab7550a98318f26b03f19283af502e59636a224d4d2854ebbbf51a14088390ad33268b301f916adaad385668c9e3f9853cac

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in networkr.gemspec
+gemspec
+gem "pry"

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    networkr (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.1)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  networkr!
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.12.5

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Yi-Ke Peng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Networkr
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/networkr`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'networkr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install networkr
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## TODO
+more robust tests
+use heap
+more flexibility
+add algorithms
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ykpeng/networkr.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "networkr"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/networkr.rb

@@ -0,0 +1,13 @@
+require "networkr/version"
+
+require "networkr/graphs/graph"
+require "networkr/graphs/digraph"
+require "networkr/graphs/multigraph"
+
+require "networkr/algorithms/dijkstra"
+require "networkr/algorithms/karger"
+require "networkr/algorithms/kosaraju"
+require "networkr/algorithms/prim"
+
+module Networkr
+end

data/lib/networkr/algorithms/dijkstra.rb

@@ -0,0 +1,35 @@
+# dijkstra
+# single-source shortest path
+
+#Takes undirected, weighted graph, nonnegative weights
+# O(|V|**2)
+
+module Networkr
+  class << self
+    def dijkstra(g, source_node)
+      nodes_processed = [source_node]
+      shortest_path_distances = {}
+      shortest_path_distances[source_node] = 0
+
+      while nodes_processed.length != g.length
+        shortest = nil
+        start_node = nil
+        end_node = nil
+        nodes_processed.each do |node|
+          g.children_of(node).each do |v, options|
+            if !nodes_processed.include?(v)
+              if shortest.nil? || shortest_path_distances[node] + options[:weight] < shortest
+                shortest = shortest_path_distances[node] + options[:weight]
+                start_node = node
+                end_node = v
+              end
+            end
+          end
+        end
+        nodes_processed << end_node
+        shortest_path_distances[end_node] = shortest
+      end
+      shortest_path_distances
+    end
+  end
+end

data/lib/networkr/algorithms/karger.rb

@@ -0,0 +1,43 @@
+=begin
+Karger's algorithm
+
+computes a minumum cut of a connected graph
+
+takes undirected multigraph
+=end
+
+module Networkr
+  class << self
+    def karger(g)
+      while g.length > 2
+        node1 = g.adj.keys.sample
+        node2 = g.children_of(node1).keys.sample
+        e = [node1, node2]
+        contract(g, node1, node2)
+      end
+      node1 = g.adj.keys[0]
+      node2 = g.adj.keys[1]
+      g.adj[node1][node2].length
+    end
+
+    def contract(g, node1, node2)
+      g.children_of(node2).each_key do |node|
+        g.add_edge(node1, node) if node != node1
+        g.adj[node].delete(node2)
+      end
+      g.adj.delete(node2)
+      g.nodes.delete(node2)
+    end
+
+    def karger_repeated(g)
+      g_copy = g.deep_copy
+
+      n = g.length
+      mincut = n
+      (n ** 3).times do
+        mincut = karger(g_copy) if karger(g_copy) < mincut
+      end
+      mincut
+    end
+  end
+end

data/lib/networkr/algorithms/kosaraju.rb

@@ -0,0 +1,88 @@
+require "set"
+
+# O(V+E), finds strongly connected components of a directed graph
+
+module Networkr
+  class Tracker
+    attr_accessor :explored, :current_source, :leaders, :current_time,
+    :finishing_times
+
+    def initialize
+      @explored = Set.new
+      @current_source = nil
+      @leaders = {}
+      @current_time = 0
+      @finishing_times = {}
+    end
+  end
+
+  class << self
+    def dfs_loop(graph, tracker)
+      graph.adj.keys.reverse_each do |i|
+        stack = [i]
+        tracker.current_source = i
+        while !stack.empty?
+          v = stack.last
+          if !tracker.explored.include?(v)
+            dfs(graph, stack, v, tracker)
+          else
+            if tracker.finishing_times[v] == nil
+              tracker.leaders[v] = tracker.current_source
+              tracker.current_time += 1
+              tracker.finishing_times[v] = tracker.current_time
+            end
+            stack.pop
+          end
+        end
+      end
+    end
+
+    def dfs(graph, stack, v, tracker)
+      tracker.explored << v
+      if !graph.adj[v]
+        tracker.leaders[v] = v
+        tracker.current_time += 1
+        tracker.finishing_times[v] = tracker.current_time
+        stack.pop
+      else
+        graph.adj[v].each_key do |w|
+          if !tracker.explored.include?(w)
+            stack << w
+          end
+        end
+      end
+    end
+
+    def kosaraju(original_graph, graph_rev, tracker1, tracker2)
+      dfs_loop(graph_rev, tracker1)
+      sorted_graph_adj = Hash[original_graph.adj.sort_by { |k, v| tracker1.finishing_times[k] }]
+      sorted_graph = DiGraph.new
+      sorted_graph.adj = sorted_graph_adj
+      dfs_loop(sorted_graph, tracker2)
+      tracker2
+    end
+
+    def kosaraju_scc_sizes(original_graph, graph_rev, tracker1, tracker2)
+      tracker2 = kosaraju(original_graph, graph_rev, tracker1, tracker2)
+      sizes(tracker2)
+    end
+
+    def kosaraju_num_scc(original_graph, graph_rev, tracker1, tracker2)
+      tracker2 = kosaraju(original_graph, graph_rev, tracker1, tracker2)
+      num_scc(tracker2)
+    end
+
+    def sizes(tracker2)
+      frequencies = Hash.new(0)
+      tracker2.leaders.each do |k, v|
+        frequencies[v] += 1
+      end
+
+      frequencies.values.sort.reverse
+    end
+
+    def num_scc(tracker2)
+      tracker2.leaders.length
+    end
+  end
+end

data/lib/networkr/algorithms/prim.rb

@@ -0,0 +1,36 @@
+=begin
+Prim's algorithm for calculating minimum spanning tree.
+
+takes weighted, undirected graph
+returns tree
+=end
+module Networkr
+  class << self
+    def prim(g, start)
+      vertices_spanned = [start]
+      tree_so_far = Graph.new
+      while vertices_spanned.length != g.length
+        e = min_edge(g, vertices_spanned)
+        tree_so_far.add_edge(e[0][0], e[0][1], weight: e[1])
+        vertices_spanned << e[0][1]
+      end
+      tree_so_far
+    end
+
+    def min_edge(g, vertices_spanned)
+      min_edge = nil
+      min_cost = 1.0/0
+      vertices_spanned.each do |u|
+        if g.adj[u]
+          g.adj[u].each do |v, options|
+            if !vertices_spanned.include?(v) && options[:weight] < min_cost
+              min_edge = [u, v]
+              min_cost = options[:weight]
+            end
+          end
+        end
+      end
+      [min_edge, min_cost]
+    end
+  end
+end

data/lib/networkr/graphs/digraph.rb

@@ -0,0 +1,108 @@
+# require_relative "graph.rb"
+=begin
+Class for directed graphs.
+
+DiGraphs hold directed edges. Self loops are allowed but parallel edges are not.
+
+See Also
+--------
+Graph
+MultiGraph
+=end
+
+module Networkr
+  class DiGraph < Graph
+
+    attr_accessor :pred, :succ
+
+    def initialize(options={})
+      super(options)
+      @pred = {}
+      @succ = @adj
+    end
+
+    def add_node(node, options={})
+      if !@succ.include?(node)
+        @succ[node] = {}
+        @pred[node] = {}
+        @nodes[node] = options
+      else
+        @nodes[node].merge!(options)
+      end
+    end
+
+    def remove_node(node)
+      if @nodes[node]
+        @nodes.delete(node)
+      else
+        raise NetworkrError, "Node #{node} is not in graph"
+      end
+
+      nbrs = @succ[node]
+      nbrs.each_key do |u|
+        @pred[u].delete(node)
+      end
+      @succ.delete(node)
+
+      @pred[node].each_key do |u|
+        @succ[u].delete(node)
+      end
+      @pred.delete(node)
+    end
+
+    def add_edge(u, v, options={})
+      if !@succ[u]
+        @succ[u] = {}
+        @pred[u] = {}
+        @nodes[u] = {}
+      end
+      if !@succ[v]
+        @succ[v] = {}
+        @pred[v] = {}
+        @nodes[v] = {}
+      end
+      data = @adj[u][v] || {}
+      data.merge!(options)
+      @succ[u][v]=data
+      @pred[v][u]=data
+    end
+
+    def remove_edge(u, v)
+      if @succ[u] && @succ[u][v]
+        @succ[u].delete(v)
+        @pred[v].delete(u)
+      else
+        raise NetworkrError, "Edge #{u}->#{v} not in graph"
+      end
+    end
+
+    def has_successor?(u, v)
+      @succ[u] && @succ[u][v]
+    end
+
+    def has_predecessor?(u, v)
+      @pred[u] && @pred[u][v]
+    end
+
+    def clear
+      @succ.clear
+      @pred.clear
+      @nodes.clear
+      @graph.clear
+    end
+
+    def is_directed?
+      true
+    end
+
+    def to_s
+      res = ''
+      @adj.each do |u, nbrs|
+        nbrs.each do |v, options|
+          res = "#{res}#{u}->#{v} #{options}\n"
+        end
+      end
+      res[0...-1]
+    end
+  end
+end

data/lib/networkr/graphs/graph.rb

@@ -0,0 +1,183 @@
+# Class for undirected graphs.
+#
+# A Graph stores nodes and edges with optional attributes.
+#
+# Graphs hold undirected edges. Self loops are allowed but parallel  edges are not.
+#
+# Nodes can be arbitrary hashable Ruby objects with optional attributes.
+#
+# Edges are represented as links between nodes with option attributes.
+#
+# Parameters
+# ----------
+# options: attributes to add to graph as key/value pairs, optional (default is {})
+#
+# See Also
+# --------
+# DiGraph
+#
+# Examples
+# --------
+# Create an empty graph with no nodes and edges.
+#
+# >>> g = Graph()
+#
+# g can be grown in several ways
+#
+# **Nodes:**
+#
+# Add one node at a time:
+#
+# >>> g.add_node(1)
+#
+# **Edges:**
+#
+# Add one edge at a time:
+#
+# >>> g.add_edge(1, 2)
+#
+# If some edges connect nodes not yet in the graph, the nodes are added automatically. There are no erros when adding nodes or edges that already exist.
+#
+# **Attributes:**
+#
+# Each graph, node, and edge can hold key/value attribute pairs in an associated attribute hash. By default these are empty, but can be added or changed using add_node, add_node, or direct manipulation of the attribute hashes named graph, nodes, and adj.
+#
+# >>> g = Graph(name: "users")
+# >>> g.graph
+# { name: "users" }
+#
+# Add/update node attributes using add_node or g.nodes:
+#
+# >>> g.add_node(1, username: "janedoe")
+# >>> g.add_node(3, username: "johndoe")
+# >>> g.nodes[1]
+# { username: "janedoe" }
+# >>> g.nodes[1][:score] = 10
+# >>> g.nodes[1].delete(:score) # remove attribute
+# >>> g.nodes
+# { 1: { username: "janedoe" }, 3: { username: "johndoe" } }
+#
+# Add/update edge attributes using add_edge or g.adj:
+#
+# >>> g.add_edge(1, 2, weight: 10)
+# >>> g.adj[1][2][:weight] = 4
+# >>> g.adj[1][2]
+# { weight: 4 }
+#
+# **Representation:**
+# :TODO
+# g.to_s
+#
+# 1-2 { weight: 4 }
+# 2-6 { weight: 10 }
+# 4-6 { weight: 8 }
+# 3-5 { weight: 5 }
+# 5-6 { weight: 1 }
+
+class NetworkrError < RuntimeError
+end
+
+module Networkr
+  class Graph
+    attr_accessor :graph, :nodes, :adj
+
+    def initialize(options = {})
+      @graph = options
+      @nodes = {}
+      @adj = {}
+    end
+
+    def add_node(node, options = {})
+      if @nodes[node]
+        @nodes[node].merge!(options)
+      else
+        @nodes[node] = options
+        @adj[node] = {}
+      end
+    end
+
+    def remove_node(node)
+      if @nodes[node]
+        @nodes.delete(node)
+      else
+        raise NetworkrError, "Node #{node} not in graph"
+      end
+
+      nbrs = @adj[node]
+      nbrs.each_key do |nbr|
+        @adj[nbr].delete(node)
+      end
+      @adj.delete(node)
+    end
+
+    def add_edge(u, v, options = {})
+      if !@nodes[u]
+        @adj[u] = {}
+        @nodes[u] = {}
+      end
+      if !@nodes[v]
+        @adj[v] = {}
+        @nodes[v] = {}
+      end
+      data = @adj[u][v] || {}
+      data.merge!(options)
+      @adj[u][v] = data
+      @adj[v][u] = data
+    end
+
+    def remove_edge(u, v)
+      if @adj[u][v]
+        @adj[u].delete(v)
+        if u != v
+          @adj[v].delete(u)
+        end
+      else
+        raise NetworkrError, "Edge #{u}-#{v} not in graph"
+      end
+    end
+
+    def children_of(node)
+      @adj[node]
+    end
+
+    def has_node?(node)
+      @nodes.include?(node)
+    end
+
+    def has_edge?(u, v)
+      @adj[u].include?(v)
+    end
+
+    def length
+      @nodes.length
+    end
+
+    def clear
+      @graph.clear
+      @nodes.clear
+      @adj.clear
+    end
+
+    def deep_copy
+      Marshal.load(Marshal.dump(self))
+    end
+
+    def is_multigraph?
+      false
+    end
+
+    def is_directed?
+      false
+    end
+
+    def to_s
+      res = ''
+      @adj.each do |u, nbrs|
+        nbrs.each do |v, options|
+          res = "#{res}#{u}-#{v} #{options}\n"
+        end
+      end
+      res[0...-1]
+    end
+  end
+end

data/lib/networkr/graphs/multigraph.rb

@@ -0,0 +1,100 @@
+# require_relative "graph.rb"
+=begin
+Class for undirected graphs that can store parallel edges.
+
+A MultiGraph holds undirected edges. Self loops are allowed.
+
+See Also
+--------
+Graph
+DiGraph
+=end
+
+module Networkr
+  class MultiGraph < Graph
+    def new_edge_key(u, v)
+=begin
+return an unused key for edges between nodes 'u' and 'v'.
+
+The nodes 'u' and 'v' do not need to be already in the graph.
+
+Notes
+-----
+
+The new key is the number of existing edges between 'u' and 'v', increased if necessary to ensure uniqueness. The first edge will have key 0, the second edge 1, etc. If an edge is removed, new keys may not be in this order.
+
+Parameters
+----------
+u, v: nodes
+
+Returns
+-------
+key: int
+=end
+      if @adj[u] && @adj[u][v]
+        keys = @adj[u][v]
+        key = keys.length
+        while keys.include?(key)
+          key += 1
+        end
+        return key
+      else
+        return 0
+      end
+    end
+
+    def add_edge(u, v, key=nil, options={})
+      if !@adj.include?(u)
+        @adj[u] = {}
+        @nodes[u] = {}
+      end
+      if !@adj.include?(v)
+        @adj[v] = {}
+        @nodes[v] = {}
+      end
+      if !key
+        key = new_edge_key(u, v)
+      end
+      if @adj[u].include?(v)
+        keys = @adj[u][v]
+        data = keys[key] || {}
+        data.merge!(options)
+        keys[key] = data
+      else
+        data = options
+        keys = {}
+        keys[key] = data
+        @adj[u][v] = keys
+        @adj[v][u] = keys
+      end
+      key
+    end
+
+    def remove_edge(u, v, key=nil)
+      keys = @adj[u][v]
+      if keys
+        if !key
+          keys.shift
+        else
+          if keys[key]
+            keys.delete(key)
+          else
+            raise NetworkrError, "Edge #{u}-#{v} with key #{key} not in graph"
+          end
+        end
+        if keys.length == 0
+          @adj[v].delete(v)
+          if u != v
+            @adj[v].delete(u)
+          end
+        end
+      else
+        raise NetworkrError, "Edge #{u}-#{v} not in graph"
+      end
+    end
+
+    def is_multigraph?
+      true
+    end
+  end
+end

data/lib/networkr/version.rb

@@ -0,0 +1,3 @@
+module Networkr
+  VERSION = "0.0.1"
+end

data/lib/utils/heap.rb

@@ -0,0 +1,111 @@
+class BinaryMinHeap
+  def initialize(&prc)
+    @store = []
+    @index_map {}
+    @prc = prc || Proc.new { |a, b| a <=> b }
+  end
+
+  def count
+    @store.length
+  end
+
+  def pop
+    return nil if count == 0
+
+    self.class.swap!(@store, @index_map, 0, count - 1)
+
+    val = @store.pop
+    @index_map.delete(val)
+
+    unless count == 0
+      self.class.heapify_down(@store, @index_map, 0, &prc)
+    end
+
+    val
+  end
+
+  def peek
+    return nil if count == 0
+    @store.first
+  end
+
+  def push(val)
+    @store << val
+    @index_map[val] = count - 1
+    self.class.heapify_up(@store, @index_map, count - 1, &prc)
+  end
+
+  def reduce!(val)
+    index = @index_map[val]
+    self.class.heapify_up(@store, @index_map, index, &prc)
+  end
+
+  protected
+  attr_accessor :prc, :store, :index_map
+
+  public
+  def self.swap!(array, index_map, i1, i2)
+    array[i1], array[i2] = array[i2], array[i1]
+    index_map[parent_val], index_map[child_val] = child_idx, parent_idx
+  end
+
+  def self.child_indices(len, parent_index)
+    [2 * parent_index + 1, 2 * parent_index + 2].select { |idx| idx < len }
+  end
+
+  def self.parent_index(child_index)
+    if child_index == 0
+      return nil
+    else
+      (child_index - 1) / 2
+    end
+  end
+
+  def self.heapify_down(array, index_map, parent_idx, len = array.length, &prc)
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    while parent_idx <= parent_index(len - 1)
+      children = child_indices(len, parent_idx)
+
+      if children.length == 1
+        smallest_child_idx = children[0]
+      else
+        child1_idx, child2_idx = children[0], children[1]
+
+        if prc.call(array[child1_idx], array[child2_idx]) <= 0
+          smallest_child_idx = child1_idx
+        else
+          smallest_child_idx = child2_idx
+        end
+      end
+
+      if prc.call(array[parent_idx], array[smallest_child_idx]) > 0
+        swap!(array, index_map, parent_idx, smallest_child_idx)
+        parent_idx = smallest_child_idx
+      else
+        break
+      end
+
+    end
+
+    array
+  end
+
+  def self.heapify_up(array, child_idx, len = array.length, &prc)
+    prc ||= Proc.new { |a, b| a <=> b }
+
+    while child_idx > 0
+      parent_idx = parent_index(child_idx)
+
+      if prc.call(array[parent_idx], array[child_idx]) > 0
+        swap!(array, index_map, parent_idx, child_idx)
+        child_idx = parent_idx
+      else
+        break
+      end
+
+    end
+
+    array
+  end
+end

data/networkr.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'networkr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "networkr"
+  spec.version       = Networkr::VERSION
+  spec.authors       = ["Yi-Ke Peng"]
+  spec.email         = ["yi.ke.peng@gmail.com"]
+
+  spec.summary       = %q{NetworkR}
+  spec.description   = %q{A gem for creating and manipulating graphs in Ruby.}
+  spec.homepage      = "http://github.com/ykpeng/networkr"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: networkr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yi-Ke Peng
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A gem for creating and manipulating graphs in Ruby.
+email:
+- yi.ke.peng@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/networkr.rb
+- lib/networkr/algorithms/dijkstra.rb
+- lib/networkr/algorithms/karger.rb
+- lib/networkr/algorithms/kosaraju.rb
+- lib/networkr/algorithms/prim.rb
+- lib/networkr/graphs/digraph.rb
+- lib/networkr/graphs/graph.rb
+- lib/networkr/graphs/multigraph.rb
+- lib/networkr/version.rb
+- lib/utils/heap.rb
+- networkr.gemspec
+homepage: http://github.com/ykpeng/networkr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: NetworkR
+test_files: []