rbutils 0.0.2 → 0.0.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NmNmZGQ1NjQ4OTljNjdhZmUyNzliNWVjMjZlZjc4ZGY0MTIzOTU0NA==
+    YmVmYmZkNjEwODUxNjE2ZTQwYWIzYTAyN2Q2MzkzYjcwNjk2YWViZA==
   data.tar.gz: !binary |-
-    MDgxZWZmNTEyZGYwOTIyZjE4MzRiYjBhM2YyNzFkMjhkYzM2N2I1Mg==
+    OTBiZTYyYzE5YjBiZmNhNjFmOTBiNGJhMzlkMDAxODYxMDYxNGJkMA==
 SHA512:
   metadata.gz: !binary |-
-    ZGJlYWYzOTMyMTNiZDc3ZDhkODIyMjZhNWUwZDI4MjkzMmRmM2E0Yjg1MmM3
-    YzJkMWI0NWFmZmRkYzlmMjI2N2IwZmQ2MGExMmIyYTIwMzJkYjBiYWVhYmQ0
-    ODFmNDkzZDk5MDVmM2I5ZDRlMjQ5ZDM3OWE0Nzc2OWFlZmY3NDA=
+    MmNiYTVmNGNiMjRjNGY4NjlmMjFmYmM2YWNhN2M1ODlhNDVkY2UyN2I4NDg5
+    Y2RlMTQ3NTY1YWYwNmUzODNiMDYzODk3MjYyYTlhZjQ5ZDVjYzYxYmY1NDhh
+    Zjc4NWE3Y2MzYjU3YzNhNTFkYzYwZTliY2Y2NmU1YmRmY2RmMjk=
   data.tar.gz: !binary |-
-    ZWExMTIyYjM2MTFlMTVjMWRlN2U3Y2NhMTRlY2RmOGFiMjhhMWQ4MzEzMTZj
-    ODE4M2FhY2ZkZTA5NDYxZjc4MGFhMDJhNjBkYmVkNGMwMDZmMzU4NDI2MDk0
-    NjM0OTEyNjlhYzFjZGUzN2ZmZjMxZjRiOGVlM2I1YTNiYTIyMmE=
+    ZjgxMjYyNjViM2Q1MDhhOWYyNzBjYTY3Y2JkMWM1YzZkNzYyYWYwNWRkNWFj
+    NjU3NzFkODliY2RjMTE2NGRiN2I4ZWVhZGUyOTRmMzBlZjEzOTkxYWE0MmRk
+    YTc2ZDUzNjgzOGQ4ZDU5NmI4NzZmYjE0NjI5MjBjMjhhZDMzNTY=

data/lib/rbutils/graph/bfs.rb

@@ -0,0 +1,45 @@
+require_relative 'Graph'
+
+class BFS < Graph
+  def initialize(graph, source)
+    @graph = graph
+    @node = source
+    @visited = []
+    @edge_to = {}
+
+    bfs(source)
+  end
+
+  def bfs(node)
+    #we have to use a queue for BFS
+    queue = []
+    #initially push the node to the queue
+    queue << node
+    #mark node as visited
+    @visited << node
+    
+    #while there are elements in the wueue,
+    #continue adding from adjacent nodes
+    while queue.any?
+      curr = queue.shift 
+      curr.adjacents.each do |adj|
+        next if @visited.include?(adj)
+        queue << adj
+        @visited << adj
+        @edge_to[adj] = curr
+      end
+    end
+  end
+  
+  #returns the path to the node after
+  #bfs has completed
+  def path_to(node)
+    return unless @visited.include?(node)
+    path = []
+    while(node != @node) do
+      path.unshift(node) 
+      node = @edge_to[node]
+    end
+    path.unshift(@node)
+  end
+end

data/lib/rbutils/graph/dfs.rb

@@ -0,0 +1,41 @@
+require_relative 'Graph'
+
+class DFS < Graph
+  def initialize(graph, source)
+    @graph = graph
+    @source = source
+    @visited = []
+    @edge_to = {}
+
+    #perform dfs
+    dfs(source)
+  end
+
+  def dfs(node)
+    #mark node as visited
+    @visited << node
+    
+    #take each adjacent node
+    node.adjacents.each do |adj|
+      next if @visited.include?(adj)
+      #perform dfs
+      dfs(adj)
+      #check edges
+      @edge_to[adj] = node
+    end
+  end
+
+  def path_to(node)
+    return unless @visited.include?(node)
+    path = []
+    curr = node
+    
+    #get the paths from the specified node to the 
+    #source
+    while(curr != @source) do
+      path.unshift(curr)
+      curr = @edge_to[curr]
+    end
+    path.unshift(@source)
+  end
+end

data/lib/rbutils/graph/dijkstra.rb

@@ -0,0 +1,67 @@
+require_relative "priorityqueue"
+
+class Dijkstra < Graph
+  
+  #source node and graph needed
+  def initialize(graph, source)
+  
+    #init variables
+    @graph = graph
+    @source = source
+    @path = {}
+    @dist_to = {}
+    @queue = PriorityQueue.new
+
+    #compute the shortest path
+    computeSP
+  end
+
+  def path_to(node)
+    path = []
+    while node != @source
+      #add node to the front of the path
+      path.unshift(node)
+      node = @path[node]
+    end
+    #add the source at the beginning
+    #invariant: source is at the front
+    # and remaining nodes in the path are behind it
+    # (reverse order)
+    path.unshift(@source)
+  end
+
+  #Computer the shortest path source the source and 
+  #Every other node
+  def computeSP
+    @graph.nodes.each do |node|
+      @dist_to[node]=Float::INFINITY
+    end
+    @dist_to[@source] = 0
+    
+    #node and it's distance to source (source -> source = 0)
+    @queue.insert(@source, 0)
+    
+    #while elements exist in the queue
+    while @queue.any?
+      #check the lowest distance (closest)
+      close = @queue.remove_min
+      #check each adjacent edge
+      close.adjacent_edges.each do |adjacent|
+        relax(adjacent)
+      end
+    end
+  end
+
+  # Check if the shortest known path is still the shortest path 
+  # That is, are there any shorter paths along this edge? 
+  def relax(edge)
+    #If the distance currently is lower than the added distance,
+    #Don't increase it.
+    return if @dist_to[edge.dest] <= @dist_to[edge.source] + edge.weight
+    
+    #Update the distance and add it back to the queue
+    @dist_to[edge.dest] = @dist_to[edge.source] + edge.weight
+    @path[edge.dest] = edge.source
+    @queue.insert(edge.dest, @dist_to[edge.dest])
+  end
+end

data/lib/rbutils/graph/edge.rb

@@ -0,0 +1,19 @@
+class Edge
+  attr_accessor :source
+  attr_accessor :dest
+  attr_accessor :weight
+
+  def initialize(source, dest, weight)
+    @source = source
+    @dest = dest
+    @weight = weight
+  end
+
+  def <=>(other)
+    self.weight <=> other.weight
+  end
+
+  def to_str
+    "#{source.to_str} => #{dest.to_str}, weight is #{weight}"
+  end
+end

data/lib/rbutils/graph/graph.rb

@@ -0,0 +1,67 @@
+require 'set'
+
+class Graph
+  attr_accessor :nodes
+  attr_accessor :edges
+  attr_accessor :connections
+
+  def initialize
+    @nodes = Set.new
+    @edges = Array.new
+    @connections = Hash.new
+  end
+
+  def add_node(node)
+    nodes << node
+    node.graph = self
+  end
+
+  #adds an edge dest the graph
+  def add_edge(source, dest, weight)
+    edges << Edge.new(source, dest, weight)
+  end
+  
+  #for BFS and DFS
+  def add_adjacency(n1, n2)
+    n1.adjacents << n2
+    n2.adjacents << n1
+  end
+  
+  #connects two nodes in the graph
+  def connect node1, node2
+    if !Set.new([node1, node2]).subset? @nodes
+      raise BadNodeInput, 'The graph does not have either ' + node1 + ' or ' + node2
+    end
+    @connections[node1] ||= Array.new
+    @connections[node1].push node2
+    unless node1.eql? node2
+      @connections[node2] ||= Array.new
+      @connections[node2].push node1
+    end
+  end
+  
+  #disconnects two nodes in the graph
+  def disconnect node1, node2
+    if !nodes.include?(node1) || !nodes.include?(node2)
+      raise NodeContainsException, 'The graph does not contain either ' + node1 + ' or ' + node2
+    end
+    @connections[node1].delete node2
+    @connections[node2].delete node1
+  end
+  
+  #returns the degree of the specified node
+  def degree node
+    d = 0
+    if (@connections[node].is_a? (Array)) && nodes.include?(node)
+      d = @connections[node].count
+      if @connections[node].include?(node)
+        d += 1
+      end
+    end
+    return d
+  end
+  
+  def adjacents node
+    @connections[node]
+  end
+end

data/lib/rbutils/graph/node.rb

@@ -0,0 +1,18 @@
+class Node
+  attr_accessor :name
+  attr_accessor :graph
+  attr_accessor :adjacents
+
+  def initialize(name)
+    @name = name
+    @adjacents = Set.new
+  end
+
+  def adjacent_edges
+    graph.edges.select{|e| e.source == self}
+  end
+
+  def to_str
+    @name
+  end
+end

data/lib/rbutils/graph/priorityqueue.rb

@@ -0,0 +1,22 @@
+class PriorityQueue
+  def initialize
+    @queue = {}
+  end
+
+  def any?
+    return @queue.any?
+  end
+
+  def insert(key, value)
+    @queue[key] = value
+    @queue.sort_by {|_key, value| value }
+  end
+    
+  def remove_max
+    @queue.shift.last
+  end
+  
+  def remove_min
+    @queue.shift.first
+  end
+end

data/lib/rbutils/neuralnet/neuralnetwork.rb

@@ -1,4 +1,4 @@
-class neuralnetwork
+class NeuralNetwork
 
     attr_accessor :inputs,                   
                   :n_inputs, 

data/lib/rbutils/sort/bubblesort.rb

@@ -0,0 +1,13 @@
+#Bubble sort implementation in Ruby
+public
+def bubblesort(array)
+  x = array.clone
+  x.each_index do |i|
+    (x.length-i-1).times do |j|
+      if (x[j+1] < x[j])
+        x[j], x[j+1] = x[j+1], x[j]
+      end
+    end
+  end
+  return x
+end

data/lib/rbutils/sort/quicksort.rb

@@ -0,0 +1,29 @@
+#Quick Sort implementation in Ruby
+public
+def quicksort(array, l, r)
+  if r == -1
+    r = array.length - 1
+  end
+
+  if l == -1
+    l = 0
+  end
+
+  if (r - l) < 1
+    return array
+  else
+    pivot = array[l]
+    i = l+1
+    for j in l+1..r
+        if array[j] < pivot
+            array[j], array[i] = array[i], array[j]
+            i += 1
+	end
+    end
+
+    array[l], array[i-1] = array[i-1], array[l]
+    array = quicksort(array, l, i-1)
+    array = quicksort(array, i, r)
+    return array
+  end
+end

data/lib/rbutils.rb

@@ -1,25 +1,11 @@
-#this needs to be changed to conform to gemspec standards
-# it needs to allow for user interface with the different classes provided. 
-class RUtils
-  def test_neuralnet() 
-        learning_rate = 10 #|rate|
-        momentum_rate = 1 #|momentum|
+require_relative 'rbutils/neuralnet/neuralnetwork'
+require_relative 'rbutils/graph/bfs'
+require_relative 'rbutils/graph/dfs'
+require_relative 'rbutils/graph/dijkstra'
+require_relative 'rbutils/graph/edge'
+require_relative 'rbutils/graph/graph'
+require_relative 'rbutils/graph/node'
+require_relative 'rbutils/graph/priorityqueue'
+require_relative 'rbutils/sort/bubblesort'
+require_relative 'rbutils/sort/quicksort'
 
-        neural_net = NeuralNetwork.new(:inputs => 2, :hidden_nodes => 10, :output_nodes => 1)
-
-        10000.times do |i|
-             neural_net.train([0, 0], [0], learning_rate, momentum_rate)
-             neural_net.train([0, 1], [0], learning_rate, momentum_rate)
-             neural_net.train([1, 0], [0], learning_rate, momentum_rate)
-             neural_net.train([1, 1], [1], learning_rate, momentum_rate)
-        end
-
-        puts "[0, 0] -> " + neural_net.predict([0, 0]).to_s
-        puts "[1, 0] -> " + neural_net.predict([1, 0]).to_s
-        puts "[0, 1] -> " + neural_net.predict([0, 1]).to_s
-        puts "[1, 1] -> " + neural_net.predict([1, 1]).to_s
-        puts "done." 
-  end
-end
-
-require 'rutils/neuralnet/neuralnetwork'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbutils
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - manan
@@ -10,18 +10,26 @@ bindir: bin
 cert_chain: []
 date: 2014-06-19 00:00:00.000000000 Z
 dependencies: []
-description: Utilities for enhanced functionality. THIS GEM IS CURRENTLY NOT COMPLETE-
-  PLEASE DO NOT DOWNLOAD. Source is at https://github.com/mananshah99/rbutils if you
-  would like to use some of the functionality pre-release.
+description: ! 'Utilities for enhanced functionality. Source is at https://github.com/mananshah99/rbutils. '
 email: manan.shah.777@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/rbutils.rb
+- lib/rbutils/graph/bfs.rb
+- lib/rbutils/graph/dfs.rb
+- lib/rbutils/graph/dijkstra.rb
+- lib/rbutils/graph/edge.rb
+- lib/rbutils/graph/graph.rb
+- lib/rbutils/graph/node.rb
+- lib/rbutils/graph/priorityqueue.rb
 - lib/rbutils/neuralnet/neuralnetwork.rb
-homepage: 
-licenses: []
+- lib/rbutils/sort/bubblesort.rb
+- lib/rbutils/sort/quicksort.rb
+homepage: https://rubygems.org/gems/rbutils
+licenses:
+- Apache
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -42,5 +50,5 @@ rubyforge_project:
 rubygems_version: 2.3.0
 signing_key: 
 specification_version: 4
-summary: Utilities for Ruby.
+summary: Multifaceted utilities for Ruby.
 test_files: []