compsci 0.1.1.1 → 0.2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4f7afa18fdbd091cf4fed0668fe59204f8f05fa
-  data.tar.gz: c123e0795298ac870f4b769f97818144e50a6f74
+  metadata.gz: 3fa74f40bbc97fa685c811d2b15738da31d69c66
+  data.tar.gz: '02965023a412fae230e7fe3e42704982c6410bab'
 SHA512:
-  metadata.gz: 9072889f4e3404d945686c1dccf2818d3fd359354f7b78fa42562ecb380918abc9899cacf14ce7e1e4c29b31542b1ba0c57b8f1f15b058b12132302fc77f8f99
-  data.tar.gz: adb4c6ec9b7b23ebc5781204db5fb1062826ee19426f8c7e3ad1098c362c535cdc0e5b71c60abe9b009ed66f4ef317b3bffa36c4f8fdbda84d37fac3555f6788
+  metadata.gz: b4832093f2d37d27b55f2b32fe20422704100d7cd515d51790d745dbf22d7006866959dc844939d2cff19e60d3ee54b78100a9785511274ed43aa22dd86a7fd8
+  data.tar.gz: 5b5ad3eeedadddd92abca745bf7822dbd9cff07fa79ccc6d34cae075d6a1c24dbc747aa1939d44806e1ad83b914b9e0b880fc6be26c505c98f869fa3dd1ff9f6

data/README.md

@@ -9,10 +9,21 @@ Provided are some toy implementations for some basic computer science problems.
 * `Node`
   - `@value`
   - `@children`
-* `ChildNode` adds
+  - `#set_child(idx, node)`
+* `KeyNode` inherits from `Node`; adds a key
+  - `@key`
+* `FlexNode` inherits from `Node`; accumulates children
+  - `#add_child(node)`
+  - `#new_child(value)`
+  - `#add_parent(node)`
+* `ChildNode` inherits from `Node`; adds a parent
   - `@parent`
   - `#gen`
   - `#siblings`
+* `ChildFlexNode` inherits from `ChildNode`; accumulates children
+  - `#add_child(node)`
+  - `#new_child(value)`
+  - `#add_parent(node)`
 
 ## [`Tree`](lib/compsci/tree.rb) data structures
 
@@ -55,16 +66,21 @@ Efficient Array implementation of a complete tree.
 * `CompleteQuaternaryTree`
   - `CompleteNaryTree.new(child_slots: 4)`
 
+## [`BinarySearchTree`](lib/compsci/binary_search_tree.rb) data structure
+
+Based on `BinaryTree` with `KeyNode`s.  The position of a node depends on its
+key and how the key relates to the existing node keys.
+
 ## [`Heap`](lib/compsci/heap.rb) data structure
 
 `CompleteNaryTree` implementation.  Both minheaps and maxheaps are supported.
 Any number of children may be provided via `child_slots`.  The primary
 operations are `Heap#push` and `Heap#pop`. See the
-[heap example](examples/heap.rb) which can be executed (among other examples)
-via `rake examples`.
+[heap](examples/heap.rb) [examples](examples/heap_push.rb)
+which can be executed (among other examples) via `rake examples`.
 
-My basic Vagrant VM gets around 500k pushes per second, constant up past 1M
-pushes.
+My basic Vagrant VM gets over [500k pushes per second, constant up past 1M
+pushes](reports/examples#L484).
 
 ## [`Fibonacci`](lib/compsci/fibonacci.rb) functions
 
@@ -142,3 +158,56 @@ cumulative: 0.828
 * `Names::Greek.upper`
 * `Names::Greek.lower`
 * `Names::Greek.symbol`
+
+## [`Simplex`](lib/compsci/simplex.rb) class
+
+The Simplex algorithm is a technique for Linear Programming.  Typically the
+problem is to maximize some linear expression of variables given some
+constraints on those variables given in terms of linear inequalities.
+
+### [`Simplex::Parse`](lib/compsci/simplex/parse.rb) functions
+
+* `Parse.tokenize` - convert a string to an array of tokens
+* `Parse.term`     - parse certain tokens into [coefficient, varname]
+* `Parse.expression` - parse a string representing a sum of terms
+* `Parse.inequality` - parse a string like "#{expression} <= #{const}"
+
+With `Simplex::Parse`, one can obtain solutions via:
+
+* `Simplex.maximize` - takes an expression to maximize followed by a variable
+                       number of constraints / inequalities; returns a solution
+* `Simplex.problem` - a more general form of `Simplex.maximize`; returns a
+                      Simplex object
+
+```ruby
+require 'compsci/simplex/parse'
+
+include CompSci
+
+Simplex.maximize('x + y',
+                 '2x + y <= 4',
+		 'x + 2y <= 3')
+
+# => [1.6666666666666667, 0.6666666666666666]
+
+
+
+s = Simplex.problem(maximize: 'x + y',
+                    constraints: ['2x + y <= 4',
+                                  'x + 2y <= 3'])
+
+# => #<CompSci::Simplex:0x0055b2deadbeef
+#      @max_pivots=10000,
+#      @num_non_slack_vars=2,
+#      @num_constraints=2,
+#      @num_vars=4,
+#      @c=[-1.0, -1.0, 0, 0],
+#      @a=[[2.0, 1.0, 1, 0], [1.0, 2.0, 0, 1]],
+#      @b=[4.0, 3.0],
+#      @basic_vars=[2, 3],
+#      @x=[0, 0, 4.0, 3.0]>
+
+s.solution
+
+# => [1.6666666666666667, 0.6666666666666666]
+```

data/Rakefile

@@ -22,20 +22,18 @@ end
 
 task default: :examples
 
+
 #
 # METRICS
 #
 
-metrics_tasks = []
-
 begin
   require 'flog_task'
   FlogTask.new do |t|
-    t.threshold = 800
+    t.threshold = 9000
     t.dirs = ['lib']
     t.verbose = true
   end
-  metrics_tasks << :flog
 rescue LoadError
   warn 'flog_task unavailable'
 end
@@ -46,7 +44,6 @@ begin
     t.dirs = ['lib']
     t.verbose = true
   end
-  metrics_tasks << :flay
 rescue LoadError
   warn 'flay_task unavailable'
 end
@@ -54,13 +51,10 @@ end
 begin
   require 'roodi_task'
   RoodiTask.new config: '.roodi.yml', patterns: ['lib/**/*.rb']
-  metrics_tasks << :roodi
 rescue LoadError
   warn "roodi_task unavailable"
 end
 
-desc "Generate code metrics reports"
-task code_metrics: metrics_tasks
 
 #
 # PROFILING
@@ -80,10 +74,11 @@ def rprof_sh(script, args = '', rprof_args = '')
 end
 
 scripts = [
-  "examples/binary_tree.rb",
   "examples/complete_tree.rb",
   "examples/heap.rb",
+  "examples/heap_push.rb",
   "examples/tree.rb",
+  "examples/tree_push.rb",
 ]
 
 desc "Run ruby-prof on examples/"
@@ -96,6 +91,22 @@ task "ruby-prof-exclude" => "loadavg" do
   scripts.each { |script| rprof_sh script, "", "--exclude-common-cycles" }
 end
 
+
+#
+# REPORTS
+#
+
+
+desc "Generate code metrics and reports"
+task report: :test do
+  %w{examples bench flog flay roodi ruby-prof ruby-prof-exclude}.each { |t|
+    sh "rake #{t} > reports/#{t} 2>&1" do |ok, _status|
+      puts "rake #{t} failed" unless ok
+    end
+  }
+end
+
+
 #
 # GEM BUILD / PUBLISH
 #

data/VERSION

@@ -1 +1 @@
-0.1.1.1
+0.2.0.1

data/compsci.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "flay", "~> 0"
   s.add_development_dependency "roodi", "~> 0"
   s.add_development_dependency "ruby-prof", "~> 0"
+  s.add_development_dependency "benchmark-ips", "~> 2.0"
 end

data/examples/binary_search_tree.rb

@@ -0,0 +1,16 @@
+require 'compsci/node'
+require 'compsci/binary_search_tree'
+require 'compsci/names'
+
+include CompSci
+
+RANDMAX = 99
+
+p vals = Names::WW1.shuffle
+p keys = Array.new(vals.size) { rand RANDMAX }
+
+root = BinarySearchTree.new_node(keys.shift, vals.shift)
+tree = BinarySearchTree.new(root)
+tree[keys.shift] = vals.shift until keys.empty?
+# tree.insert(keys.shift, vals.shift) until keys.empty?
+puts tree

data/examples/heap.rb

@@ -3,48 +3,6 @@ require 'compsci/timer'
 
 include CompSci
 
-puts <<EOF
-#
-# 3 seconds worth of pushes
-#
-
-EOF
-
-count = 0
-start = Timer.now
-start_100k = Timer.now
-h = Heap.new
-
-loop {
-  count += 1
-
-  if count % 10000 == 0
-    _answer, push_elapsed = Timer.elapsed { h.push rand 99999 }
-    puts "%ith push: %0.8f s" % [count, push_elapsed]
-    if count % 100000 == 0
-      h.push rand 99999
-      push_100k_elapsed = Timer.since start_100k
-      puts "-------------"
-      puts "    100k push: %0.8f s (%ik push / s)" %
-           [push_100k_elapsed, 100.to_f / push_100k_elapsed]
-      puts
-      start_100k = Timer.now
-    end
-  else
-    h.push rand 99999
-  end
-
-  break if Timer.since(start) > 3
-}
-
-puts "pushed %i items in %0.1f s" % [count, Timer.since(start)]
-puts
-
-print "still a heap with #{h.size} items? "
-answer, elapsed = Timer.elapsed { h.heap? }
-puts "%s - %0.3f sec" % [answer ? 'YES' : 'NO', elapsed]
-puts
-
 puts <<EOF
 #
 # display the results of TernaryHeap push and pop

data/examples/heap_push.rb

@@ -0,0 +1,46 @@
+require 'compsci/heap'
+require 'compsci/timer'
+
+include CompSci
+
+puts <<EOF
+#
+# 3 seconds worth of pushes
+#
+
+EOF
+
+count = 0
+start = Timer.now
+start_100k = Timer.now
+h = Heap.new
+
+loop {
+  count += 1
+
+  if count % 10000 == 0
+    _answer, push_elapsed = Timer.elapsed { h.push rand 99999 }
+    puts "%ith push: %0.8f s" % [count, push_elapsed]
+    if count % 100000 == 0
+      h.push rand 99999
+      push_100k_elapsed = Timer.since start_100k
+      puts "-------------"
+      puts "    100k push: %0.8f s (%ik push / s)" %
+           [push_100k_elapsed, 100.to_f / push_100k_elapsed]
+      puts
+      start_100k = Timer.now
+    end
+  else
+    h.push rand 99999
+  end
+
+  break if Timer.since(start) > 3
+}
+
+puts "pushed %i items in %0.1f s" % [count, Timer.since(start)]
+puts
+
+print "still a heap with #{h.size} items? "
+answer, elapsed = Timer.elapsed { h.heap? }
+puts "%s - %0.3f sec" % [answer ? 'YES' : 'NO', elapsed]
+puts

data/examples/tree.rb

@@ -1,3 +1,4 @@
+require 'compsci/node'
 require 'compsci/tree'
 require 'compsci/timer'
 
@@ -16,7 +17,7 @@ vals = Array.new(30) { rand 99 }
   # start with the same vals for each class
   my_vals = vals.dup
   p my_vals
-  tree = tree_class.new(ChildNode, my_vals.shift)
+  tree = tree_class.new(ChildFlexNode, my_vals.shift)
   tree.push my_vals.shift until my_vals.empty?
   p tree
   puts tree.display(width: 80)

data/examples/{binary_tree.rb → tree_push.rb}

@@ -1,3 +1,4 @@
+require 'compsci/node'
 require 'compsci/tree'
 require 'compsci/timer'
 
@@ -13,7 +14,7 @@ EOF
 count = 0
 start = Timer.now
 start_1k = Timer.now
-tree = BinaryTree.new ChildNode, rand(99)
+tree = BinaryTree.new ChildFlexNode, rand(99)
 
 loop {
   count += 1
@@ -50,7 +51,7 @@ EOF
 vals = Array.new(30) { rand 99 }
 p vals
 
-tree = BinaryTree.new ChildNode, vals.shift
+tree = BinaryTree.new ChildFlexNode, vals.shift
 tree.push vals.shift until vals.empty?
 puts tree
 

data/lib/compsci/binary_search_tree.rb

@@ -0,0 +1,86 @@
+require 'compsci/node'
+require 'compsci/tree'
+
+module CompSci
+  class BinarySearchTree < BinaryTree
+    def self.display_level(nodes: [], width: 80)
+      unless self.power_of?(nodes.size, 2)
+        raise "unexpected node count: #{nodes.size}"
+      end
+      block_width = [width / nodes.size, 1].max
+      nodes.map { |node|
+        str = node ? node.to_s : '_'
+        space = [(block_width + str.size) / 2, str.size + 1].max
+        str.ljust(space, ' ').rjust(block_width, ' ')
+      }.join
+    end
+
+    # helper method; any object which responds to key, value, and children
+    # may be used
+    def self.new_node(key, val)
+      CompSci::KeyNode.new(val, key: key, children: 2)
+    end
+
+    def self.new_with_kv(key, val)
+      self.new(self.new_node(key, val))
+    end
+
+    def initialize(root_node)
+      @node_class = root_node.class
+      @child_slots = 2
+      if root_node.children.size == @child_slots
+        @root = root_node
+      else
+        raise "bad root: #{root_node}; expected #{@child_slots} child slots"
+      end
+    end
+
+    def search_recursive(key, node: @root)
+      return node if node.nil? or node.key == key
+      child = key < node.key ? node.children[0] : node.children[1]
+      search_recursive(key, node: child)
+    end
+
+    def search_iterative(key, node: @root)
+      while !node.nil?
+        return node if node.key == key
+        node = key < node.key ? node.children[0] : node.children[1]
+      end
+      node
+    end
+
+    def insert_recursive(key, val, node: @root)
+      return nil if node.nil? or node.key == key
+      if key < node.key
+        if node.children[0]
+          insert_recursive(key, val, node: node.children[0])
+        else
+          node.children[0] = @node_class.new(val, key: key, children: 2)
+        end
+      else
+        if node.children[1]
+          insert_recursive(key, val, node: node.children[1])
+        else
+          node.children[1] = @node_class.new(val, key: key, children: 2)
+        end
+      end
+    end
+    alias_method :insert, :insert_recursive
+    alias_method :[]=, :insert
+
+    def display(node: @root, width: 80)
+      levels = [self.class.display_level(nodes: [node], width: width)]
+      nodes = node.children
+      while nodes.any? { |n| !n.nil? }
+        levels << self.class.display_level(nodes: nodes, width: width)
+        children = []
+        nodes.each { |n|
+          children += n ? n.children : Array.new(@child_slots)
+        }
+        nodes = children
+      end
+      levels.join("\n")
+    end
+    alias_method :to_s, :display
+  end
+end

data/lib/compsci/fibonacci.rb

@@ -1,7 +1,7 @@
 autoload :Matrix, 'matrix'
 
 module CompSci
-  class Fibonacci
+  module Fibonacci
     def self.classic(n)
       n < 2 ? n : classic(n-1) + classic(n-2)
     end
@@ -17,20 +17,12 @@ module CompSci
       cache[n]
     end
 
-    # traditional
     def self.dynamic(n)
       a, b = 0, 1
       n.times { a, b = b, a+b }
       a
     end
 
-    # fails for n == 0
-    def self.dynamic_fast(n)
-      a, b = 0, 1
-      (n-1).times { a, b = b, a+b }
-      b
-    end
-
     # https://gist.github.com/havenwood/02cf291b809327d96a3f
     # slower than dynamic until around n == 500
     def self.matrix(n)