RubyGems - algorithm_selector - Versions diffs - 0.1.0 - Mend

algorithm_selector 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

data/doc/top-level-namespace.html ADDED

@@ -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