RubyGems - algorithm_selector - Versions diffs - 0.1.0 - Mend

algorithm_selector 0.1.0

Files changed (42) hide show

checksums.yaml +7 -0
data/.DS_Store +0 -0
data/.gitignore +1 -0
data/.yardoc/checksums +2 -0
data/.yardoc/object_types +0 -0
data/.yardoc/objects/root.dat +0 -0
data/.yardoc/proxy_types +0 -0
data/CODE_OF_CONDUCT.md +49 -0
data/Gemfile +4 -0
data/LICENSE.txt +21 -0
data/README.md +45 -0
data/Rakefile +6 -0
data/algorithm_selector.gemspec +35 -0
data/bin/console +14 -0
data/bin/setup +8 -0
data/doc/AlgorithmSelector.html +505 -0
data/doc/BSTNode.html +440 -0
data/doc/BinaryTree.html +572 -0
data/doc/LinkNode.html +440 -0
data/doc/LinkedList.html +879 -0
data/doc/Queue.html +569 -0
data/doc/Searches.html +442 -0
data/doc/Sorts.html +916 -0
data/doc/Stack.html +723 -0
data/doc/_index.html +183 -0
data/doc/class_list.html +51 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +58 -0
data/doc/css/style.css +481 -0
data/doc/file.README.html +129 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +17 -0
data/doc/index.html +129 -0
data/doc/js/app.js +243 -0
data/doc/js/full_list.js +216 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +507 -0
data/doc/top-level-namespace.html +114 -0
data/lib/.DS_Store +0 -0
data/lib/algorithm_selector.rb +562 -0
data/lib/algorithm_selector/version.rb +3 -0
metadata +129 -0

@@ -0,0 +1,114 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.9.4
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <iframe id="search_frame" src="class_list.html"></iframe>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="AlgorithmSelector.html" title="AlgorithmSelector (module)">AlgorithmSelector</a></span>
+      <strong class="classes">Classes:</strong> <span class='object_link'><a href="BSTNode.html" title="BSTNode (class)">BSTNode</a></span>, <span class='object_link'><a href="BinaryTree.html" title="BinaryTree (class)">BinaryTree</a></span>, <span class='object_link'><a href="LinkNode.html" title="LinkNode (class)">LinkNode</a></span>, <span class='object_link'><a href="LinkedList.html" title="LinkedList (class)">LinkedList</a></span>, <span class='object_link'><a href="Queue.html" title="Queue (class)">Queue</a></span>, <span class='object_link'><a href="Searches.html" title="Searches (class)">Searches</a></span>, <span class='object_link'><a href="Sorts.html" title="Sorts (class)">Sorts</a></span>, <span class='object_link'><a href="Stack.html" title="Stack (class)">Stack</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Fri Jul 22 11:22:30 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>
+    </div>
+  </body>
+</html>

data/lib/.DS_Store ADDED

Binary file

data/lib/algorithm_selector.rb ADDED

@@ -0,0 +1,562 @@
+require "algorithm_selector/version"
+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)
+    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)
+    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)
+    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)
+    end
+  end
+  # call sort algorithm method
+  def sort(array, algorithm_name)
+    method = Sorts.new.method(algorithm_name)
+    method.call(array)
+  end
+end
+# Sorts class
+class Sorts
+  # Show all results from sorting algorithms
+  def all(array, num_tests)
+    {
+      sorted: merge_sort(array),
+      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)
+      }
+    }
+  end
+  # Show the best sorting algorithm
+  def best(array, num_tests)
+    hash = all(array, num_tests)
+    best_time = 0
+    best_algorithm = {}
+    hash[:results].each do |key, val|
+      if val < best_time || best_time == 0
+        best_time = val
+        best_algorithm = Hash[key, val]
+      end
+    end
+    {
+      best_algorithm.keys[0] => best_algorithm[best_algorithm.keys[0]]
+    }
+  end
+  # Analyze specific sorting algorithm by name
+  def analyze(array, algorithm, num_tests)
+    hash = all(array, num_tests)
+    alg = {}
+    hash[:results].each do |key, val|
+      if algorithm.to_sym == key
+        alg = Hash[key, val]
+      end
+    end
+    {
+      sorted: hash[:sorted],
+      alg.keys[0] => alg[alg.keys[0]]
+    }
+  end
+  # Compare two algorithms for data set
+  def compare(array, first_algorithm, second_algorithm, num_tests)
+    hash = all(array, num_tests)
+    first = {}
+    second = {}
+    hash[:results].each do |key, val|
+      if first_algorithm.to_sym == key
+        first = Hash[key, val]
+      elsif second_algorithm.to_sym == key
+        second = Hash[key, val]
+      end
+    end
+    {
+      first.keys[0] => first[first.keys[0]],
+      second.keys[0] => second[second.keys[0]]
+    }
+  end
+  # Bubble sort
+  # 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
+    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
+          switched = true
+        end
+      end
+    end
+    return array
+  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]
+      j = i - 1
+      while (j >= 0 && array[j] > value) do
+        array[j+1] = array[j]
+        j = j - 1
+      end
+      array[j+1] = value
+    end
+    array
+  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|
+      min = i
+      (i+1...array.length).to_a.each do |j|
+        if (array[j] < array[min])
+          min = j
+        end
+      end
+      if min != i
+        array[min], array[i] = array[i], array[min]
+      end
+    end
+    return array
+  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]
+    merge(merge_sort(left), merge_sort(right))
+  end
+  # Quick sort
+  # 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}
+    quick_sort(left) + [pivot] + quick_sort(right)
+  end
+end
+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)
+    {
+      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)
+        }
+    }
+  end
+  def best(array, num_tests, target)
+    hash = all(array, num_tests, target)
+    best_time = 0
+    best_algorithm = {}
+    hash[:results].each do |key, val|
+      if val < best_time || best_time == 0
+        best_time = val
+        best_algorithm = Hash[key, val]
+      end
+    end
+    {
+      best_algorithm.keys[0] => best_algorithm[best_algorithm.keys[0]]
+    }
+  end
+  def analyze(array, algorithm, num_tests, target)
+    hash = all(array, num_tests, target)
+    alg = {}
+    hash[:results].each do |key, val|
+      if algorithm.to_sym == key
+        alg = Hash[key, val]
+      end
+    end
+    {
+      found: hash[:found],
+      alg.keys[0] => alg[alg.keys[0]]
+    }
+  end
+  def compare(array, first_algorithm, second_algorithm, num_tests, target)
+    hash = all(array, num_tests, target)
+    first = {}
+    second = {}
+    hash[:results].each do |key, val|
+      if first_algorithm.to_sym == key
+        first = Hash[key, val]
+      elsif second_algorithm.to_sym == key
+        second = Hash[key, val]
+      end
+    end
+    {
+      first.keys[0] => first[first.keys[0]],
+      second.keys[0] => second[second.keys[0]]
+    }
+  end
+end
+# Stack data structure
+# Worst-Case Space Complexity: O(n)
+class Stack
+  def initialize(size, array=[])
+    @size = size
+    @store = Array.new(@size)
+    @top = -1
+    array.each { |el| push(el) }
+  end
+  # Search, Average-Case Time Complexity: O(n)
+  # Search, Worst-Case Time Complexity: O(n)
+  def search(target)
+    found = false
+    new_stack = Stack.new(@size)
+    until empty? do
+      new_stack.push(pop)
+      if new_stack.look == target
+        found = true
+        break
+      end
+    end
+    push(new_stack.pop) until new_stack.empty?
+    found
+  end
+  # Deletion, Worst-Case Time Complexity: O(1)
+  def pop
+    if empty?
+      nil
+    else
+      popped = @store[@top]
+      @store[@top] = nil
+      @top = @top.pred
+      popped
+    end
+  end
+  # Insertion, Worst-Case Time Complexity: O(1)
+  def push(el)
+    if full? or el.nil?
+      nil
+    else
+      @top = @top.succ
+      @store[@top] = el
+      self
+    end
+  end
+  def size
+    @size
+  end
+  def look
+    @store[@top]
+  end
+  def full?
+    @top == (@size - 1)
+  end
+  def empty?
+    @top == -1
+  end
+end
+# Queue data structure
+# Worst-Case Space Complexity: O(n)
+class Queue
+  def initialize(size, array=[])
+    @size = size
+    @store = Array.new(@size)
+    @head, @tail = -1, 0
+    # initialize Queue with array if given
+    array.each { |el| enqueue(el) }
+  end
+  # Search, Worst-Case Time Complexity: O(n)
+  def search(target)
+    found = false
+    @size.times do
+      found = true if look == target
+      enqueue(dequeue)
+    end
+    found
+  end
+  # Deletion, Worst-Case Time Complexity: O(1)
+  def dequeue
+    if empty?
+      nil
+    else
+      @tail = @tail.succ
+      dequeued = @store[@head]
+      @store.unshift(nil)
+      @store.pop
+      dequeued
+    end
+  end
+  # Insertion, Worst-Case Time Complexity: O(1)
+  def enqueue(el)
+    if full? or el.nil?
+      nil
+    else
+      @tail = @tail.pred
+      @store[@tail] = el
+      self
+    end
+  end
+  def size
+    @size
+  end
+  def look
+    @store[@head]
+  end
+  private
+  def empty?
+    @head == -1 and @tail == 0
+  end
+  def full?
+    @tail.abs == (@size)
+  end
+end
+# Singly-Linked List data structure
+# Worst-Case Space Complexity: O(n)
+class LinkedList
+  include Enumerable
+  def initialize(array=[])
+    @head = LinkNode.new
+    @tail = LinkNode.new
+    @head.next = @tail
+    @tail.prev = @head
+    array.each { |i| insert(i) }
+  end
+  # Search, Worst-Case Time Complexity: O(n)
+  def search(target)
+    each { |current_link| return current_link.val if current_link.val == target }
+  end
+  def [](i)
+    each_with_index { |link, j| return link if i == j }
+    nil
+  end
+  def first
+    empty? ? nil : @head.next
+  end
+  def last
+    empty? ? nil : @tail.prev
+  end
+  def empty?
+    @head.next == @tail
+  end
+  def get(val)
+    each { |link| return link.val if link.val == val }
+    nil
+  end
+  def include?(val)
+    any? { |link| link.val == val }
+  end
+  # Insertion, Worst-Case Time Complexity: O(1)
+  def insert(val)
+    each { |link| return link.val = val if link.val == val }
+    new_link = LinkNode.new(val)
+    @tail.prev.next = new_link
+    new_link.prev = @tail.prev
+    new_link.next = @tail
+    @tail.prev = new_link
+    new_link
+  end
+  # Deletion, Worst-Case Time Complexity: O(1)
+  def remove(val)
+    each do |link|
+      if link.val == val
+        link.prev.next = link.next
+        link.next.prev = link.prev
+        link.next, link.prev = nil, nil
+        return link.val
+      end
+    end
+    nil
+  end
+  def each
+    current_link = @head.next
+    until current_link == @tail
+      yield current_link
+      current_link = current_link.next
+    end
+  end
+end
+# Binary Search Tree data structure
+# Worst-Case Space Complexity: O(n)
+class BinaryTree
+  attr_accessor :root
+  def initialize(array=[], root_val=nil)
+    @root = BSTNode.new(root_val)
+    array.each { |i| insert(i) }
+  end
+  # Search, Worst-Case Time Complexity: O(n)
+  def search(target)
+    return nil if @root.nil?
+    return search_in_tree(@root, target)
+  end
+  def search_in_tree(tree_node, target)
+    return nil if tree_node.nil?
+    return tree_node.val if target == tree_node.val
+    if target < tree_node.val
+      search_in_tree(tree_node.left, target)
+    else
+      search_in_tree(tree_node.right, target)
+    end
+  end
+  # Insertion, Worst-Case Time Complexity: O(n)
+  def insert(val)
+    new_node = BSTNode.new(val)
+    @root = new_node and return unless @root.val
+    insert_to_tree(@root, new_node)
+  end
+  def insert_to_tree(tree_node, new_node)
+    tree_node = new_node and return if tree_node.nil?
+    return tree_node if tree_node.val == new_node.val
+    if new_node.val > tree_node.val
+      insert_to_tree(tree_node.right, new_node) unless tree_node.right.nil?
+      tree_node.right = new_node
+    else
+      insert_to_tree(tree_node.left, new_node) unless tree_node.left.nil?
+      tree_node.left = new_node
+    end
+  end
+end
+private
+# Helper method to get time required for method to run
+def display_time(prc, num_tests)
+  total = 0
+  num_tests.times do
+    start = Time.now
+    prc.call
+    finish = Time.now
+    total = total + (finish - start)
+  end
+  total/num_tests
+end
+# Helper method for merge_sort
+def merge(left, right)
+  array = []
+  until left.length == 0 || right.length == 0
+    if left.first > right.first
+      array << right.shift
+    else
+      array << left.shift
+    end
+  end
+  array.concat(left).concat(right)
+end
+# Node helper class for Linked List
+class LinkNode
+  attr_accessor :val, :next, :prev
+  def initialize(val=nil)
+    @val = val
+    @next = nil
+    @prev = nil
+  end
+end
+# Node helper class for Binary Search Tree
+class BSTNode
+  attr_accessor :val, :left, :right
+  def initialize(val=nil, left=nil, right=nil)
+    @val = val
+    @left = left
+    @right = right
+  end
+end