compsci 0.3.0.1 → 0.3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6b9d3fa913e9dc0f7aa9f8711e9aa231c00d1022
-  data.tar.gz: 8436157b3364c791cee0471ae74ca3817f0f4dde
+SHA256:
+  metadata.gz: 5a7f1f7282649dec4f08ef08ce3eb3b5b3b97183137624deaa9f20567650185a
+  data.tar.gz: 57081ef332e9adc6d3dbdc06b3ff2c9c76955d26b4fdd90402b7547b5544e0fd
 SHA512:
-  metadata.gz: 1670fd7283f147996dea2ed2a7a190797a33a5b22b60e8ccfa98a5dc48d61aa6a43302badbc7776b6b7c5a7171a32923ed2dc95f88c23ca998bd1d023d3f4f72
-  data.tar.gz: f30dd40fb2e5f9e04db6044d7801f1776fb0e1214fd23c29bfbef028dbcd87cab612e434e4df43da477012975561cb7eeef6dab867a53e479612893c53a9e086
+  metadata.gz: cdb60b8e1230cdc175ac43afca1efe51bb163ce71dfb2cdd29ffa8ff8ab586456ec181dd46389d54b768edb360f5f9f56d6729bbd65ee86fcd7fa7acee0f417e
+  data.tar.gz: 3f20b69bd337aebc862a7f40e1e1177386979f71065200fa18e4dd69bdefb3a382dd8cbd066903d2ba5793cf5c71acd9cd09b79088c4c15b38982b8196bfb0c2

data/README.md

@@ -1,88 +1,105 @@
-[![Build Status](https://travis-ci.org/rickhull/compsci.svg?branch=master)](https://travis-ci.org/rickhull/compsci)
+[![CI Status](https://github.com/rickhull/compsci/actions/workflows/ci.yaml/badge.svg)](https://github.com/rickhull/compsci/actions/workflows/ci.yaml)
+[![Gem Version](https://badge.fury.io/rb/compsci.svg)](https://badge.fury.io/rb/compsci)
 
 # CompSci
 
 Provided are some toy implementations for some basic computer science problems.
 
-## [`Node`](lib/compsci/node.rb) data structure
+## [`Node`](lib/compsci/node.rb) classes
+
+### `Node`
+
+A *Node* provides a tree structure by assigning other *Nodes* to `@children`.
 
 * `Node`
   - `@value`
   - `@children`
-  - `#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
+  - `#[]`     - child node at index
+  - `#[]=`    - set child node at index
+  - `display` - display full tree with all descendents
+
+* [examples/tree.rb](examples/tree.rb)
+* [test/node.rb](test/node.rb#L7)
+
+### `KeyNode`
+
+A *KeyNode* adds `@key` and allows a comparison based search on the key.
+[Binary search trees](https://en.wikipedia.org/wiki/Binary_search_tree)
+are supported, and the `@duplicated` flag determines whether duplicate keys
+are allowed to be inserted.  Any duplicates will not be returned from
+`#search`.  A Ternary search tree is also supported, and it inherently allows
+duplicates keys.  `#search` returns an array of `KeyNode`, possibly empty.
+
+* `KeyNode < Node`
+  - `KeyNode.key_cmp_idx` - compare 2 keys to decide on a child slot
+  - `@key`        - any *Comparable*
+  - `@duplicates` - boolean flag relevant for @children.size == 2
+  - `#cidx`       - calls `KeyNode.key_cmp_idx`
+  - `#insert`
+  - `#search`
+
+* [examples/binary_search_tree.rb](examples/binary_search_tree.rb)
+* [examples/ternary_search_tree.rb](examples/ternary_search_tree.rb)
+* [test/node.rb](test/node.rb#L43)
+
+### `ChildNode`
+
+A *ChildNode* adds reference to its `@parent`.
+
+* `ChildNode < Node`
   - `@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
-
-* `Tree`
-  - `@root`
-  - `#df_search`
-  - `#bf_search`
-* `NaryTree`
-  - `@child_slots` (number of children per node)
-  - `#open_parent` O(n) to find a node with open child slots
-  - `#push` append `#open_parent.children`
-  - `#display` if initialized with `ChildNode`
-* `BinaryTree`
-  - `NaryTree.new(child_slots: 2)`
-  - `#display` for `Node` and `ChildNode`
-* `TernaryTree`
-  - `NaryTree.new(child_slots: 3)`
-* `QuaternaryTree`
-  - `NaryTree.new(child_slots: 4)`
-
-## [`CompleteNaryTree`](lib/compsci/complete_tree.rb) data structure
-
-Efficient Array implementation of a complete tree.
-
-* `CompleteNaryTree`
-  - `CompleteNaryTree.parent_idx`
-  - `CompleteNaryTree.children_idx`
-  - `CompleteNaryTree.gen`
+
+* [test/node.rb](test/node.rb#L190)
+
+## [`CompleteTree`](lib/compsci/complete_tree.rb) classes
+
+Efficient *Array* implementation of a complete tree uses arithmetic to
+determine parent/child relationships.
+
+* `CompleteTree`
+  - `CompleteTree.parent_idx`
+  - `CompleteTree.children_idx`
+  - `CompleteTree.gen`
   - `@array`
   - `@child_slots`
   - `#push`
   - `#pop`
   - `#size`
   - `#last_idx`
-  - `#display` (alias `#to_s`)
-* `CompleteBinaryTree`
-  - `CompleteNaryTree.new(child_slots: 2)`
-* `CompleteTernaryTree`
-  - `CompleteNaryTree.new(child_slots: 3)`
-* `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](examples/heap.rb) [examples](examples/heap_push.rb)
-which can be executed (among other examples) via `rake examples`.
+  - `#display` - alias `#to_s`
+* `CompleteBinaryTree < CompleteTree`
+  - `@child_slots = 2`
+* `CompleteTernaryTree < CompleteTree`
+  - `@child_slots = 3`
+* `CompleteQuaternaryTree < CompleteTree`
+  - `@child_slots = 4`
+
+* [examples/complete_tree.rb](examples/complete_tree.rb)
+* [test/complete_tree.rb](test/complete_tree.rb)
+* [test/bench/complete_tree.rb](test/bench/complete_tree.rb)
+
+## [`Heap`](lib/compsci/heap.rb) class
+
+*CompleteTree* 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`. My basic Vagrant VM
+gets over [500k pushes per second](reports/examples#L533), constant up past
+1M pushes.
+
+* `Heap < CompleteTree`
+  - `#push`
+  - `#pop`
+  - `#sift_up`
+  - `#sift_down`
 
-My basic Vagrant VM gets over [500k pushes per second, constant up past 1M
-pushes](reports/examples#L484).
+* [examples/heap.rb](examples/heap.rb)
+* [examples/heap_push.rb](examples/heap_push.rb)
+* [test/heap.rb](test/heap.rb)
+* [test/bench/heap.rb](test/bench/heap.rb)
 
-## [`Fibonacci`](lib/compsci/fibonacci.rb) functions
+## [`Fibonacci`](lib/compsci/fibonacci.rb) module
 
 * `Fibonacci.classic(n)`         - naive, recursive
 * `Fibonacci.cache_recursive(n)` - as above, caching already computed results
@@ -90,13 +107,22 @@ pushes](reports/examples#L484).
 * `Fibonacci.dynamic(n)`         - as above but without a cache structure
 * `Fibonacci.matrix(n)`          - matrix is magic; beats dynamic around n=500
 
-## [`Timer`](/lib/compsci/timer.rb) functions
+* [test/fibonacci.rb](test/fibonacci.rb)
+* [test/bench/fibonacci.rb](test/bench/fibonacci.rb)
+
+## [`Timer`](/lib/compsci/timer.rb) module
 
 * `Timer.now`      - uses `Process::CLOCK_MONOTONIC` if available
 * `Timer.since`    - provides the elapsed time since a prior time
 * `Timer.elapsed`  - provides the elapsed time to run a block
 * `Timer.loop_avg` - loops a block; returns final value and mean elapsed time
 
+* [examples/heap_push.rb](examples/heap_push.rb)
+* [test/timer.rb](test/timer.rb)
+* [test/bench/complete_tree.rb](test/bench/complete_tree.rb)
+* [test/bench/simplex.rb](test/bench/simplex.rb)
+* [test/timer.rb](test/timer.rb)
+
 ```ruby
 require 'compsci/timer'
 
@@ -142,36 +168,69 @@ elapsed: 0.304
 cumulative: 0.828
 ```
 
-## [`Fit`](lib/compsci/fit.rb) functions
+## [`Fit`](lib/compsci/fit.rb) module
 
 * `Fit.sigma` - sums the result of a block applied to array values
 * `Fit.error` - returns a generic r^2 value, the coefficient of determination
-* `Fit.constant` - fits `y = a + 0x`; returns the mean and variance
+* `Fit.constant`    - fits `y = a + 0x`; returns the mean and variance
 * `Fit.logarithmic` - fits `y = a + b*ln(x)`; returns a, b, r^2
-* `Fit.linear` - fits `y = a + bx`; returns a, b, r^2
-* `Fit.exponential` fits `y = ae^(bx)`; returns a, b, r^2
-* `Fit.power` fits `y = ax^b`; returns a, b, r^2
+* `Fit.linear`      - fits `y = a + bx`; returns a, b, r^2
+* `Fit.exponential` - fits `y = ae^(bx)`; returns a, b, r^2
+* `Fit.power`       - fits `y = ax^b`; returns a, b, r^2
+* `Fit.best`        - applies known fits; returns the fit with highest r^2
+
+* [test/bench/complete_tree.rb](test/bench/complete_tree.rb)
+* [test/fit.rb](test/fit.rb)
+
+## [`Names`](lib/compsci/names.rb) module
 
-## [`Names`](lib/compsci/names.rb) functions
+This helps map a range of small integers to friendly names, typically in
+alphabetical order.
 
+* `ENGLISH_UPPER` `ENGLISH_LOWER` `WW1` `WW2` `NATO` `CRYPTO` `PLANETS` `SOLAR`
 * `Names.assign`
-* `Names::Greek.upper`
-* `Names::Greek.lower`
-* `Names::Greek.symbol`
+
+* [examples/binary_search_tree.rb](examples/binary_search_tree.rb)
+* [examples/ternary_search_tree.rb](examples/ternary_search_tree.rb)
+* [test/names.rb](test/names.rb)
+* [test/node.rb](test/node.rb)
+
+### [`Names::Greek`](lib/compsci/names/greek.rb) module
+
+- `UPPER` `LOWER` `SYMBOLS` `CHAR_MAP` `LATIN_SYMBOLS` `SYMBOLS26`
+- `Names::Greek.upper`
+- `Names::Greek.lower`
+- `Names::Greek.sym`
+
+### [`Names::Pokemon`](lib/compsci/names/pokemon.rb) module
+
+- `Names::Pokemon.array`
+- `Names::Pokemon.hash`
+- `Names::Pokemon.grep`
+- `Names::Pokemon.sample`
 
 ## [`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.
+### WORK IN PROGRESS; DO NOT USE
+
+The [Simplex algorithm](https://en.wikipedia.org/wiki/Simplex_algorithm)
+is a technique for
+[Linear programming](https://en.wikipedia.org/wiki/Linear_programming).
+Typically the problem is to maximize some linear expression of variables
+given some constraints on those variables in terms of linear inequalities.
 
-### [`Simplex::Parse`](lib/compsci/simplex/parse.rb) functions
+* [test/bench/simplex.rb](test/bench/simplex.rb)
+* [test/simplex.rb](test/simplex.rb)
+
+### [`Simplex::Parse`](lib/compsci/simplex/parse.rb) module
 
 * `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}"
 
+* [test/simplex_parse.rb](test/simplex_parse.rb)
+
 With `Simplex::Parse`, one can obtain solutions via:
 
 * `Simplex.maximize` - takes an expression to maximize followed by a variable

data/Rakefile

@@ -78,7 +78,9 @@ scripts = [
   "examples/heap.rb",
   "examples/heap_push.rb",
   "examples/tree.rb",
-  "examples/tree_push.rb",
+  "examples/flex_node.rb",
+  "examples/binary_search_tree.rb",
+  "examples/ternary_search_tree.rb",
 ]
 
 desc "Run ruby-prof on examples/"

data/VERSION

@@ -1 +1 @@
-0.3.0.1
+0.3.2.1

data/compsci.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/rickhull/compsci"
   s.license = "LGPL-3.0"
 
-  s.required_ruby_version = "~> 2"
+  s.required_ruby_version = "~> 3.0"
 
   s.version = File.read(File.join(__dir__, 'VERSION')).chomp
 
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "buildar", "~> 3.0"
   s.add_development_dependency "minitest", "~> 5.0"
-  s.add_development_dependency "rake", "~> 0"
+  s.add_development_dependency "rake", "~> 12.3" # CVE-2020-8130
   s.add_development_dependency "flog", "~> 0"
   s.add_development_dependency "flay", "~> 0"
   s.add_development_dependency "roodi", "~> 0"

data/examples/binary_search_tree.rb

@@ -1,16 +1,51 @@
 require 'compsci/node'
-require 'compsci/binary_search_tree'
 require 'compsci/names'
 
 include CompSci
 
-RANDMAX = 99
+puts <<EOF
+
+#
+# Insert nodes into a BST (random keys, duplicates: true)
+#
+
+EOF
+
+randmax = 99
 
 p vals = Names::WW1.shuffle
-p keys = Array.new(vals.size) { rand RANDMAX }
+p keys = Array.new(vals.size) { rand randmax }
+
+root = KeyNode.new(vals.shift, key: keys.shift, children: 2, duplicates: true)
+root.insert(keys.shift, vals.shift) until keys.empty?
+
+puts root.display
+puts
+
+puts <<EOF
+
+#
+# Insert 30 nodes into a BST (unique keys, duplicates: false)
+#
+
+EOF
+
+keys = (1..30).to_a.shuffle
+vals = keys.map { rand 99 }
+
+root = KeyNode.new(vals.shift, key: keys.shift, children: 2)
+root.insert(keys.shift, vals.shift) while !keys.empty?
+puts root.display
+
+puts <<EOF
+
+#
+# Search for 30 different keys
+#
+
+EOF
 
-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
+(1..30).each { |key|
+  node = root.search(key)
+  puts "found #{node}"
+}

data/examples/complete_tree.rb

@@ -1,47 +1,46 @@
 require 'compsci/complete_tree'
-require 'compsci/timer'
 
 include CompSci
 
-puts <<EOF
+vals = Array.new(30) { rand 99 }
+
+[CompleteBinaryTree,
+ CompleteTernaryTree,
+ CompleteQuaternaryTree].each { |tree_class|
+
+  puts <<EOF
+
 #
-# Print CompleteBinary-, Ternary-, and QuaternaryTree
+# Print #{tree_class} filled with static vals
 #
 
 EOF
 
-vals = Array.new(30) { rand 99 }
-
-[CompleteBinaryTree,
- CompleteTernaryTree,
- CompleteQuaternaryTree,
-].each { |tree_class|
-  # start with the same vals for each class
   my_vals = vals.dup
-  p my_vals
+  puts "initial vals: #{my_vals.inspect}"
   tree = tree_class.new
   tree.push my_vals.shift until my_vals.empty?
+
   p tree
-  puts tree.display(width: 80)
-  puts
   puts
+  puts tree.display(width: 80)
   puts
 
 
-  # TODO: add CompleteTree#df_search
-  # tree.df_search { |n|
-  #   puts "visited #{n}"
-  #   false # or n.value > 90
-  # }
-  # puts
+  puts <<EOF
+
+#
+# Push random vals and print again
+#
+
+EOF
 
-  # push different vals for each class
   my_vals = Array.new(30) { rand 99 }
-  puts "push: #{my_vals.inspect}"
+  puts "new vals: #{my_vals.inspect}"
 
   tree.push my_vals.shift until my_vals.empty?
-  puts tree.display(width: 80)
   puts
+  puts tree.display(width: 80)
   puts
   puts
 }

data/examples/flex_node.rb

@@ -0,0 +1,117 @@
+require 'compsci/flex_node'
+require 'compsci/timer'
+
+include CompSci
+
+puts <<EOF
+
+#
+# Try out Binary, Ternary, and Quaternary FlexNodes
+# Push the same vals to each
+#
+
+EOF
+
+vals = Array.new(30) { rand 99 }
+
+[2, 3, 4].each { |child_slots|
+  my_vals = vals.dup
+  p my_vals
+
+  root = ChildFlexNode.new my_vals.shift
+  root.push(my_vals.shift, child_slots) until my_vals.empty?
+  p root
+  puts root.display(width: 80)
+  puts
+  visited = []
+  root.df_search { |n|
+    visited << n
+    false # or n.value > 90
+  }
+  puts "df_search visited: %s" % visited.join(' ')
+  puts
+  puts
+
+  # push different vals for each class
+  my_vals = Array.new(30) { rand 99 }
+  puts "push: #{my_vals.inspect}"
+  root.push(my_vals.shift, child_slots) until my_vals.empty?
+  puts
+  puts root.display(width: 80)
+  puts
+  puts
+}
+
+puts <<EOF
+
+#
+# 30 ChildFlexNode pushes and df_search
+#
+
+EOF
+
+vals = Array.new(30) { rand 99 }
+p vals
+
+root = ChildFlexNode.new vals.shift
+child_slots = 2
+root.push(vals.shift, child_slots) until vals.empty?
+p root
+puts root.display
+puts
+
+root.df_search { |n|
+  puts "visited #{n}"
+  false # or n.value > 90
+}
+puts
+
+vals = Array.new(30) { rand 99 }
+puts "push: #{vals.inspect}"
+
+root.push(vals.shift, child_slots) until vals.empty?
+puts root.display
+puts
+
+
+runtime = (ARGV.shift || "3").to_i
+puts <<EOF
+
+#
+# #{runtime} seconds worth of Binary ChildFlexNode pushes
+#
+
+EOF
+
+count = 0
+start = Timer.now
+start_1k = Timer.now
+root = ChildFlexNode.new(rand 99)
+child_slots = 2
+
+loop {
+  count += 1
+
+  if count % 100 == 0
+    _ans, push_elapsed = Timer.elapsed {
+      root.push(rand(99), child_slots)
+    }
+    puts "%ith push: %0.8f s" % [count, push_elapsed]
+
+    if count % 1000 == 0
+      push_1k_elapsed = Timer.since start_1k
+      puts "-----------"
+      puts "    1k push: %0.4f s (%i push / s)" %
+           [push_1k_elapsed, 1000.to_f / push_1k_elapsed]
+      puts
+      start_1k = Timer.now
+    end
+  else
+    root.push(rand(99), child_slots)
+  end
+
+  break if Timer.since(start) > runtime
+}
+
+puts "pushed %i items in %0.1f s" % [count, Timer.since(start)]
+puts

data/examples/heap.rb

@@ -1,11 +1,11 @@
 require 'compsci/heap'
-require 'compsci/timer'
 
 include CompSci
 
 puts <<EOF
+
 #
-# display the results of TernaryHeap push and pop
+# display the results of ternary Heap push and pop
 #
 
 EOF
@@ -38,3 +38,41 @@ puts "array: #{h.array.inspect}"
 puts "heap: #{h.heap?}"
 puts h
 puts
+
+
+puts <<EOF
+
+#
+# display the results of binary Heap push and pop
+#
+
+EOF
+
+h = Heap.new(child_slots: 2)
+
+puts "push: %s" % Array.new(30) { rand(99).tap { |i| h.push i } }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "pop: %i" % h.pop
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "pop: %s" % Array.new(9) { h.pop }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts
+puts
+
+puts "push: %s" % Array.new(30) { rand(99).tap { |i| h.push i } }.join(' ')
+puts "array: #{h.array.inspect}"
+puts "heap: #{h.heap?}"
+puts h
+puts

data/examples/heap_push.rb

@@ -6,12 +6,18 @@ include CompSci
 runtime = (ARGV.shift || "3").to_i
 
 puts <<EOF
+
 #
-# 3 seconds worth of pushes
+# #{runtime} seconds worth of Heap pushes
 #
 
 EOF
 
+
+# pregenerate a sequence of random numbers
+# every NUMBERWANGth request, shift the sequence and push a new random
+# this should mitigate random number generation from interfering with timing
+# while also mitigating any chance of cyclic behavior
 RANDMAX = 1_000
 NUMBERWANG = 1_000
 NUMS = (0..(RANDMAX - 1)).to_a.shuffle

data/examples/ternary_search_tree.rb

@@ -0,0 +1,30 @@
+require 'compsci/node'
+require 'compsci/names'
+
+include CompSci
+
+randmax = (ARGV.shift || 50).to_i
+
+puts <<EOF
+
+#
+# Insert #{randmax} nodes into a ternary search tree (random keys)
+#
+
+EOF
+
+root = KeyNode.new(rand(randmax), key: rand(randmax), children: 3)
+randmax.times { puts root.insert(rand(randmax), rand(randmax)) }
+puts root.display
+
+puts <<EOF
+
+#
+# Search for #{randmax} keys in order
+#
+
+EOF
+
+randmax.times { |key|
+  puts "search #{key}: #{root.search(key).map { |n| n.value }.join(' ')}"
+}