algorithm_selector 0.1.1 → 0.1.2

data/doc/top-level-namespace.html

@@ -104,7 +104,7 @@
 </div>
 
       <div id="footer">
-  Generated on Fri Jul 22 11:22:30 2016 by
+  Generated on Sat Jul 23 23:26:27 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.9.4 (ruby-2.1.2).
 </div>

data/lib/algorithm_selector.rb

@@ -1,71 +1,75 @@
 require "algorithm_selector/version"
 
+# algorithm-selector library; 5 methods (all, best, analyze, compare, sort)
 module AlgorithmSelector
   extend self
 
-  # get all algorithms
-  def all(type, array, num_tests=1, target=nil)
-    if type == "sort"
-      Sorts.new.all(array, num_tests)
-    elsif type == "search"
-      Searches.new.all(array, num_tests, target)
+  # Returns the times for each algorithm
+  def all(action, data_set, trials=1, target=nil)
+    if action == "sort"
+      Sorts.new.all(data_set, trials)
+    elsif action == "search"
+      Searches.new.all(data_set, trials, target)
     end
   end
 
-  # get best algorithm
-  def best(type, array, num_tests=1, target=nil)
-    if type == "sort"
-      Sorts.new.best(array, num_tests)
-    elsif type == "search"
-      Searches.new.best(array, num_tests, target)
+  # Returns the algorithm with the best time
+  def best(action, data_set, trials=1, target=nil)
+    if action == "sort"
+      Sorts.new.best(data_set, trials)
+    elsif action == "search"
+      Searches.new.best(data_set, trials, target)
     end
   end
 
-  # get one algorithm by name
-  def analyze(type, array, algorithm_name, num_tests=1, target=nil)
-    if type == "sort"
-      Sorts.new.analyze(array, algorithm_name, num_tests)
-    elsif type == "search"
-      Searches.new.analyze(array, algorithm_name, num_tests, target)
+  # Returns time for specified algorithm or data structure
+  def analyze(action, data_set, algorithm, trials=1, target=nil)
+    if action == "sort"
+      Sorts.new.analyze(data_set, algorithm, trials)
+    elsif action == "search"
+      Searches.new.analyze(data_set, algorithm, trials, target)
     end
   end
 
-  # compare two algorithms
-  def compare(type, array, first_algorithm_name, second_algorithm_name, num_tests=1, target=nil)
-    if type == "sort"
-      Sorts.new.compare(array, first_algorithm_name, second_algorithm_name, num_tests)
-    elsif type == "search"
-      Searches.new.compare(array, first_algorithm_name, second_algorithm_name, num_tests, target)
+  # Returns the times of two specified algorithms for comparison
+  def compare(action, data_set, first_algorithm, second_algorithm, trials=1, target=nil)
+    if action == "sort"
+      Sorts.new.compare(data_set, first_algorithm, second_algorithm, trials)
+    elsif action == "search"
+      Searches.new.compare(data_set, first_algorithm, second_algorithm, trials, target)
     end
   end
 
-  # call sort algorithm method
-  def sort(array, algorithm_name)
-    method = Sorts.new.method(algorithm_name)
-    method.call(array)
+  # Returns sorted data_set of specified sorting algorithm
+  def sort(data_set, algorithm)
+    method = Sorts.new.method(algorithm)
+    method.call(data_set)
   end
 
 end
 
 # Sorts class
+# 4 methods corresponding to algorithm_selector module
+# 5 sorting algorithms (selection, insertion, bubble, merge, quick)
 class Sorts
+
   # Show all results from sorting algorithms
-  def all(array, num_tests)
+  def all(data_set, trials)
     {
-      sorted: merge_sort(array),
+      sorted: merge_sort(data_set),
       results: {
-        bubble_sort: display_time(Proc.new {bubble_sort(array)}, num_tests),
-        insertion_sort: display_time(Proc.new {insertion_sort(array)}, num_tests),
-        selection_sort: display_time(Proc.new {selection_sort(array)}, num_tests),
-        merge_sort: display_time(Proc.new {merge_sort(array)}, num_tests),
-        quick_sort: display_time(Proc.new {quick_sort(array)}, num_tests)
+        bubble_sort: display_time(Proc.new {bubble_sort(data_set)}, trials),
+        insertion_sort: display_time(Proc.new {insertion_sort(data_set)}, trials),
+        selection_sort: display_time(Proc.new {selection_sort(data_set)}, trials),
+        merge_sort: display_time(Proc.new {merge_sort(data_set)}, trials),
+        quick_sort: display_time(Proc.new {quick_sort(data_set)}, trials)
       }
     }
   end
 
   # Show the best sorting algorithm
-  def best(array, num_tests)
-    hash = all(array, num_tests)
+  def best(data_set, trials)
+    hash = all(data_set, trials)
     best_time = 0
     best_algorithm = {}
     hash[:results].each do |key, val|
@@ -79,9 +83,9 @@ class Sorts
     }
   end
 
-  # Analyze specific sorting algorithm by name
-  def analyze(array, algorithm, num_tests)
-    hash = all(array, num_tests)
+  # Show specific sorting algorithm by name
+  def analyze(data_set, algorithm, trials)
+    hash = all(data_set, trials)
     alg = {}
     hash[:results].each do |key, val|
       if algorithm.to_sym == key
@@ -94,9 +98,9 @@ class Sorts
     }
   end
 
-  # Compare two algorithms for data set
-  def compare(array, first_algorithm, second_algorithm, num_tests)
-    hash = all(array, num_tests)
+  # Show comparison of two algorithms
+  def compare(data_set, first_algorithm, second_algorithm, trials)
+    hash = all(data_set, trials)
     first = {}
     second = {}
     hash[:results].each do |key, val|
@@ -116,69 +120,69 @@ class Sorts
   # Worst-Case Space Complexity: O(1)
   # Averge-Case Time Complexity: O(n^2)
   # Worst-Case Time Complexity: O(n^2)
-  def bubble_sort(array)
-    return array if array.length < 2
+  def bubble_sort(data_set)
+    return data_set if data_set.length < 2
     switched = true
     until switched == false
       switched = false
-      (1...array.length).each do |i|
-        if array[i-1] > array[i]
-          temp = array[i]
-          array[i] = array[i-1]
-          array[i-1] = temp
+      (1...data_set.length).each do |i|
+        if data_set[i-1] > data_set[i]
+          temp = data_set[i]
+          data_set[i] = data_set[i-1]
+          data_set[i-1] = temp
           switched = true
         end
       end
     end
-    return array
+    return data_set
   end
 
   # Insertion sort
   # Worst-Case Space Complexity: O(1)
   # Averge-Case Time Complexity: O(n^2)
   # Worst-Case Time Complexity: O(n^2)
-  def insertion_sort(array)
-    return array if array.length < 2
-    (1...array.length).to_a do |i|
-      value = array[i]
+  def insertion_sort(data_set)
+    return data_set if data_set.length < 2
+    (1...data_set.length).to_a do |i|
+      value = data_set[i]
       j = i - 1
-      while (j >= 0 && array[j] > value) do
-        array[j+1] = array[j]
+      while (j >= 0 && data_set[j] > value) do
+        data_set[j+1] = data_set[j]
         j = j - 1
       end
-      array[j+1] = value
+      data_set[j+1] = value
     end
-    array
+    data_set
   end
 
   # Selection sort
   # Worst-Case Space Complexity: O(1)
   # Averge-Case Time Complexity: O(n^2)
   # Worst-Case Time Complexity: O(n^2)
-  def selection_sort(array)
-    (0...array.length-1).to_a.each do |i|
+  def selection_sort(data_set)
+    (0...data_set.length-1).to_a.each do |i|
       min = i
-      (i+1...array.length).to_a.each do |j|
-        if (array[j] < array[min])
+      (i+1...data_set.length).to_a.each do |j|
+        if (data_set[j] < data_set[min])
           min = j
         end
       end
       if min != i
-        array[min], array[i] = array[i], array[min]
+        data_set[min], data_set[i] = data_set[i], data_set[min]
       end
     end
-    return array
+    return data_set
   end
 
   # Merge sort
   # Worst-Case Space Complexity: O(n)
   # Averge-Case Time Complexity: O(n log(n))
   # Worst-Case Time Complexity: O(n log(n))
-  def merge_sort(array)
-    return array if array.length < 2
-    middle = array.length/2
-    left = array[0...middle]
-    right = array[middle...array.length]
+  def merge_sort(data_set)
+    return data_set if data_set.length < 2
+    middle = data_set.length/2
+    left = data_set[0...middle]
+    right = data_set[middle...data_set.length]
     merge(merge_sort(left), merge_sort(right))
   end
 
@@ -186,35 +190,40 @@ class Sorts
   # Worst-Case Space Complexity: O(log(n))
   # Averge-Case Time Complexity: O(n log(n))
   # Worst-Case Time Complexity: O(n^2)
-  def quick_sort(array)
-    return array if array.count < 2
-    pivot = array[0]
-    left = array.select {|el| el < pivot}
-    right = array.select {|el| el > pivot}
+  def quick_sort(data_set)
+    return data_set if data_set.count < 2
+    pivot = data_set[0]
+    left = data_set.select {|el| el < pivot}
+    right = data_set.select {|el| el > pivot}
     quick_sort(left) + [pivot] + quick_sort(right)
   end
 end
 
+# Searches class
+# 4 methods corresponding to algorithm_selector module
 class Searches
-  def all(array, num_tests, target)
-    stack = Stack.new(array.length, array)
-    queue = Queue.new(array.length, array)
-    linked_list = LinkedList.new(array)
-    binary_tree = BinaryTree.new(array)
+
+  # Show all data structures for searching
+  def all(data_set, trials, target)
+    stack = Stack.new(data_set.length, data_set)
+    queue = Queue.new(data_set.length, data_set)
+    linked_list = LinkedList.new(data_set)
+    binary_tree = BinaryTree.new(data_set)
     {
       found: stack.search(target),
       results:
         {
-          stack: display_time(Proc.new {stack.search(target)}, num_tests),
-          queue: display_time(Proc.new {queue.search(target)}, num_tests),
-          linked_list: display_time(Proc.new {linked_list.search(target)}, num_tests),
-          binary_tree: display_time(Proc.new {binary_tree.search(target)}, num_tests)
+          stack: display_time(Proc.new {stack.search(target)}, trials),
+          queue: display_time(Proc.new {queue.search(target)}, trials),
+          linked_list: display_time(Proc.new {linked_list.search(target)}, trials),
+          binary_tree: display_time(Proc.new {binary_tree.search(target)}, trials)
         }
     }
   end
 
-  def best(array, num_tests, target)
-    hash = all(array, num_tests, target)
+  # Show best data structure for searching
+  def best(data_set, trials, target)
+    hash = all(data_set, trials, target)
     best_time = 0
     best_algorithm = {}
     hash[:results].each do |key, val|
@@ -228,8 +237,9 @@ class Searches
     }
   end
 
-  def analyze(array, algorithm, num_tests, target)
-    hash = all(array, num_tests, target)
+  # Show analysis of a data structure for searching
+  def analyze(data_set, algorithm, trials, target)
+    hash = all(data_set, trials, target)
     alg = {}
     hash[:results].each do |key, val|
       if algorithm.to_sym == key
@@ -242,8 +252,9 @@ class Searches
     }
   end
 
-  def compare(array, first_algorithm, second_algorithm, num_tests, target)
-    hash = all(array, num_tests, target)
+  # Show comparison of two data structures for searching
+  def compare(data_set, first_algorithm, second_algorithm, trials, target)
+    hash = all(data_set, trials, target)
     first = {}
     second = {}
     hash[:results].each do |key, val|
@@ -263,11 +274,11 @@ end
 # Stack data structure
 # Worst-Case Space Complexity: O(n)
 class Stack
-  def initialize(size, array=[])
+  def initialize(size, data_set=[])
     @size = size
     @store = Array.new(@size)
     @top = -1
-    array.each { |el| push(el) }
+    data_set.each { |el| push(el) }
   end
 
   # Search, Average-Case Time Complexity: O(n)
@@ -286,7 +297,6 @@ class Stack
     found
   end
 
-  # Deletion, Worst-Case Time Complexity: O(1)
   def pop
     if empty?
       nil
@@ -329,13 +339,13 @@ end
 # Queue data structure
 # Worst-Case Space Complexity: O(n)
 class Queue
-  def initialize(size, array=[])
+  def initialize(size, data_set=[])
     @size = size
     @store = Array.new(@size)
     @head, @tail = -1, 0
 
-    # initialize Queue with array if given
-    array.each { |el| enqueue(el) }
+    # initialize Queue with data_set if given
+    data_set.each { |el| enqueue(el) }
   end
 
   # Search, Worst-Case Time Complexity: O(n)
@@ -348,7 +358,6 @@ class Queue
     found
   end
 
-  # Deletion, Worst-Case Time Complexity: O(1)
   def dequeue
     if empty?
       nil
@@ -396,12 +405,12 @@ end
 class LinkedList
   include Enumerable
 
-  def initialize(array=[])
+  def initialize(data_set=[])
     @head = LinkNode.new
     @tail = LinkNode.new
     @head.next = @tail
     @tail.prev = @head
-    array.each { |i| insert(i) }
+    data_set.each { |i| insert(i) }
   end
 
   # Search, Worst-Case Time Complexity: O(n)
@@ -473,9 +482,9 @@ end
 class BinaryTree
   attr_accessor :root
 
-  def initialize(array=[], root_val=nil)
+  def initialize(data_set=[], root_val=nil)
     @root = BSTNode.new(root_val)
-    array.each { |i| insert(i) }
+    data_set.each { |i| insert(i) }
   end
 
   # Search, Worst-Case Time Complexity: O(n)
@@ -517,28 +526,29 @@ end
 private
 
 # Helper method to get time required for method to run
-def display_time(prc, num_tests)
+# Returns time in seconds
+def display_time(prc, trials)
   total = 0
-  num_tests.times do
+  trials.times do
     start = Time.now
     prc.call
     finish = Time.now
     total = total + (finish - start)
   end
-  total/num_tests
+  total/trials
 end
 
 # Helper method for merge_sort
 def merge(left, right)
-  array = []
+  data_set = []
   until left.length == 0 || right.length == 0
     if left.first > right.first
-      array << right.shift
+      data_set << right.shift
     else
-      array << left.shift
+      data_set << left.shift
     end
   end
-  array.concat(left).concat(right)
+  data_set.concat(left).concat(right)
 end
 
 # Node helper class for Linked List

data/lib/algorithm_selector/version.rb

@@ -1,3 +1,3 @@
 module AlgorithmSelector
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithm_selector
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - joseph
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-22 00:00:00.000000000 Z
+date: 2016-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,8 +53,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 description: |-
-  A gem for determing the most efficient algorithm or data structure to use for a particular data set.
-                            Currently supports the following data structures and algorithms: Bubble Sort, Insertion Sort, Selection Sort, Merge Sort, Quick Sort, Stack, Queue, Linked List, Binary Search Tree
+  Calculates algorithms and data structures for sorting and searching. Selects best one to use for particular data set.
+                            Currently supports: Bubble Sort, Insertion Sort, Selection Sort, Merge Sort, Quick Sort, Stack, Queue, Linked List, Binary Search Tree
 email:
 - jnvbui@gmail.com
 executables: []