compsci 0.3.0.1 → 0.3.2.1

data/lib/compsci/timer.rb

@@ -1,5 +1,9 @@
 module CompSci
-  module Timer
+  class Timer
+    SECS_PER_MIN = 60
+    MINS_PER_HOUR = 60
+    SECS_PER_HOUR = SECS_PER_MIN * MINS_PER_HOUR
+
     # lifted from seattlerb/minitest
     if defined? Process::CLOCK_MONOTONIC
       def self.now
@@ -32,5 +36,61 @@ module CompSci
       }
       return val, self.since(start) / i.to_f
     end
+
+    # YYYY-MM-DD HH::MM::SS.mmm
+    def self.timestamp(t)
+      t.strftime "%Y-%m-%d %H:%M:%S.%L"
+    end
+
+    # HH::MM::SS.mmm.uuuuuuuu
+    def self.elapsed_display(elapsed_ms, show_us: false)
+      elapsed_s, ms = elapsed_ms.divmod 1000
+      ms_only, ms_fraction = ms.round(8).divmod 1
+
+      h = elapsed_s / SECS_PER_HOUR
+      elapsed_s -= h * SECS_PER_HOUR
+      m, s = elapsed_s.divmod SECS_PER_MIN
+
+      hmsms = [[h, m, s].map { |i| i.to_s.rjust(2, '0') }.join(':'),
+               ms_only.to_s.rjust(3, '0')]
+      hmsms << (ms_fraction * 10 ** 8).round.to_s.ljust(8, '0') if show_us
+      hmsms.join('.')
+    end
+
+    def restart(t = Time.now)
+      @start = t
+      self
+    end
+    alias_method :initialize, :restart
+
+    def timestamp(t = Time.now)
+      self.class.timestamp t
+    end
+
+    def timestamp!(t = Time.now)
+      puts '-' * 70, timestamp(t), '-' * 70
+    end
+
+    def elapsed(t = Time.now)
+      t - @start
+    end
+
+    def elapsed_ms(t = Time.now)
+      elapsed(t) * 1000
+    end
+
+    def elapsed_display(t = Time.now)
+      self.class.elapsed_display(elapsed_ms(t))
+    end
+    alias_method :to_s, :elapsed_display
+    alias_method :inspect, :elapsed_display
+
+    def stamp(msg = '', t = Time.now)
+      format("%s %s", elapsed_display(t), msg)
+    end
+
+    def stamp!(msg = '', t = Time.now)
+      puts stamp(msg, t)
+    end
   end
 end

data/lib/compsci.rb

@@ -1 +1,10 @@
-module CompSci; end
+module CompSci
+  # thanks apeiros
+  # https://gist.github.com/rickhull/d0b579aa08c85430b0dc82a791ff12d6
+  def self.power_of?(num, base)
+    return false if base <= 1
+    mod = 0
+    num, mod = num.divmod(base) until num == 1 || mod > 0
+    mod == 0
+  end
+end

data/test/bench/fibonacci.rb

@@ -1,143 +1,44 @@
 require 'compsci/fibonacci'
-require 'minitest/autorun'
-require 'minitest/benchmark'
+require 'benchmark/ips'
 
 include CompSci
 
-# CLASSIC_RANGE = [3, 5, 10, 15, 20, 25, 30, 31, 32, 33, 34, 35]
-CLASSIC_RANGE = [10, 15, 20, 25, 30, 31, 32, 33, 34, 35]
-# RECURSIVE_RANGE = [10, 100, 1000, 2500, 5000, 7500]
-RECURSIVE_RANGE = [100, 1000, 2500, 5000, 7500]
-# CACHE_RANGE = [100, 1000, 10000, 100000, 112500, 125000]
-CACHE_RANGE = [100, 1000, 10000, 100000]
+# recursive benchmarks with low N; iterative for comparison
+Benchmark.ips do |b|
+  b.config time: 3, warmup: 0.5
+  num = 25
 
-# this causes churn at the process level and impacts other benchmarks
-# DYNAMIC_RANGE = [100, 1000, 10000, 100000, 200000, 500000]
-DYNAMIC_RANGE = [100, 1000, 10000, 100000]
-MATRIX_RANGE = [100, 1000, 10000, 100000]
+  b.report("Fibonacci.classic(#{num})") {
+    Fibonacci.classic(num)
+  }
 
-#SPEC_BENCHMARK = true
-#CLASS_BENCHMARK = true
-BENCHMARK_IPS = true
-SPEC_BENCHMARK = false
-CLASS_BENCHMARK = false
-#BENCHMARK_IPS = false
+  b.report("Fibonacci.cache_recursive(#{num})") {
+    Fibonacci.cache_recursive(num)
+  }
 
+  b.report("Fibonacci.cache_iterative(#{num})") {
+    Fibonacci.cache_iterative(num)
+  }
 
-if SPEC_BENCHMARK
-  describe "Fibonacci.classic Benchmark" do
-    bench_range do
-      CLASSIC_RANGE
-    end
-
-    fc = ["Fibonacci.classic (exponential, 0.95)", 0.95]
-    bench_performance_exponential(*fc) do |n|
-      Fibonacci.classic(n)
-    end
-  end
-
-  describe "Fibonacci.cache_recursive Benchmark" do
-    bench_range do
-      RECURSIVE_RANGE
-    end
-
-    fcr = ["Fibonacci.cache_recursive (linear, 0.95)", 0.95]
-    bench_performance_linear(*fcr) do |n|
-      Fibonacci.cache_recursive(n)
-    end
-  end
-
-  describe "Fibonacci.cache_iterative Benchmark" do
-    bench_range do
-      CACHE_RANGE
-    end
-
-    fci = ["Fibonacci.cache_iterative (linear, 0.99)", 0.99]
-    bench_performance_linear(*fci) do |n|
-      Fibonacci.cache_iterative(n)
-    end
-  end
-
-  describe "Fibonacci.dynamic Benchmark" do
-    bench_range do
-      DYNAMIC_RANGE
-    end
-
-    fd = ["Fibonacci.dynamic (linear, 0.99)", 0.99]
-    bench_performance_linear(*fd) do |n|
-      Fibonacci.dynamic(n)
-    end
-  end
-
-  describe "Fibonacci.matrix Benchmark" do
-    bench_range do
-      MATRIX_RANGE
-    end
-
-    fd = ["Fibonacci.matrix (linear, 0.99)", 0.99]
-    bench_performance_linear(*fd) do |n|
-      Fibonacci.matrix(n)
-    end
-  end
+  b.compare!
 end
 
-if CLASS_BENCHMARK
-  require 'compsci/timer'
-
-  class BenchFib < Minitest::Benchmark
-    def bench_fib
-      times = CLASSIC_RANGE.map { |n|
-        _answer, elapsed = Timer.elapsed { Fibonacci.classic(n) }
-        elapsed
-      }
-      _a, _b, r2 = self.fit_exponential(CLASSIC_RANGE, times)
-      puts
-      puts "self-timed Fibonacci.classic(n) exponential fit: %0.3f" % r2
-      puts
-    end
-  end
-end
-
-if BENCHMARK_IPS
-  require 'benchmark/ips'
-
-  # recursive benchmarks with low N; iterative for comparison
-  Benchmark.ips do |b|
-    b.config time: 3, warmup: 0.5
-    num = 25
-
-    b.report("Fibonacci.classic(#{num})") {
-      Fibonacci.classic(num)
-    }
-
-    b.report("Fibonacci.cache_recursive(#{num})") {
-      Fibonacci.cache_recursive(num)
-    }
-
-    b.report("Fibonacci.cache_iterative(#{num})") {
-      Fibonacci.cache_iterative(num)
-    }
-
-    b.compare!
-  end
-
-  # nonrecursive benchmarks with high N
-  Benchmark.ips do |b|
-    b.config time: 3, warmup: 0.5
-    num = 500
+# nonrecursive benchmarks with high N
+Benchmark.ips do |b|
+  b.config time: 3, warmup: 0.5
+  num = 500
 
-    b.report("Fibonacci.cache_iterative(#{num})") {
-      Fibonacci.cache_iterative(num)
-    }
+  b.report("Fibonacci.cache_iterative(#{num})") {
+    Fibonacci.cache_iterative(num)
+  }
 
-    b.report("Fibonacci.dynamic(#{num})") {
-      Fibonacci.dynamic(num)
-    }
+  b.report("Fibonacci.dynamic(#{num})") {
+    Fibonacci.dynamic(num)
+  }
 
-    b.report("Fibonacci.matrix(#{num})") {
-      Fibonacci.matrix(num)
-    }
+  b.report("Fibonacci.matrix(#{num})") {
+    Fibonacci.matrix(num)
+  }
 
-    b.compare!
-  end
+  b.compare!
 end

data/test/bench/flex_node.rb

@@ -0,0 +1,30 @@
+require 'compsci/flex_node'
+require 'benchmark/ips'
+
+include CompSci
+
+Benchmark.ips do |b|
+  b.config time: 3, warmup: 0.5
+
+  b.report("99x Binary ChildFlexNode#push") do
+    @root = ChildFlexNode.new 42
+    99.times { @root.push rand(99), 2 }
+  end
+
+  b.report("99x Binary FlexNode#push") do
+    @root = FlexNode.new 42
+    99.times { @root.push rand(99), 2 }
+  end
+
+  b.report("99x Ternary ChildFlexNode#push") do
+    @root = ChildFlexNode.new 42
+    99.times { @root.push rand(99), 3 }
+  end
+
+  b.report("99x Ternary FlexNode#push") do
+    @root = FlexNode.new 42
+    99.times { @root.push rand(99), 3 }
+  end
+
+  b.compare!
+end

data/test/complete_tree.rb

@@ -1,9 +1,11 @@
 require 'compsci/complete_tree'
 require 'minitest/autorun'
 
+Minitest::Test.parallelize_me!
+
 include CompSci
 
-describe CompleteNaryTree do
+describe CompleteTree do
   it "must calculate a parent index for N=2" do
     valid = {
       1 => 0,
@@ -24,10 +26,10 @@ describe CompleteNaryTree do
       -2 => -2,
     }
     valid.each { |idx, pidx|
-      CompleteNaryTree.parent_idx(idx, 2).must_equal pidx
+      expect(CompleteTree.parent_idx(idx, 2)).must_equal pidx
     }
     invalid.each { |idx, pidx|
-      CompleteNaryTree.parent_idx(idx, 2).must_equal pidx
+      expect(CompleteTree.parent_idx(idx, 2)).must_equal pidx
     }
   end
 
@@ -53,10 +55,10 @@ describe CompleteNaryTree do
     }
 
     valid.each { |idx, cidx|
-      CompleteNaryTree.children_idx(idx, 2).must_equal cidx
+      expect(CompleteTree.children_idx(idx, 2)).must_equal cidx
     }
     invalid.each { |idx, cidx|
-      CompleteNaryTree.children_idx(idx, 2).must_equal cidx
+      expect(CompleteTree.children_idx(idx, 2)).must_equal cidx
     }
   end
 
@@ -80,10 +82,10 @@ describe CompleteNaryTree do
       -2 => -1,
     }
     valid.each { |idx, pidx|
-      CompleteNaryTree.parent_idx(idx, 3).must_equal pidx
+      expect(CompleteTree.parent_idx(idx, 3)).must_equal pidx
     }
     invalid.each { |idx, pidx|
-      CompleteNaryTree.parent_idx(idx, 3).must_equal pidx
+      expect(CompleteTree.parent_idx(idx, 3)).must_equal pidx
     }
   end
 
@@ -102,28 +104,28 @@ describe CompleteNaryTree do
     }
 
     valid.each { |idx, cidx|
-      CompleteNaryTree.children_idx(idx, 3).must_equal cidx
+      expect(CompleteTree.children_idx(idx, 3)).must_equal cidx
     }
     invalid.each { |idx, cidx|
-      CompleteNaryTree.children_idx(idx, 3).must_equal cidx
+      expect(CompleteTree.children_idx(idx, 3)).must_equal cidx
     }
   end
 
   describe "instance" do
     before do
       @array = (0..99).sort_by { rand }
-      @empty = CompleteNaryTree.new(child_slots: 5)
+      @empty = CompleteTree.new(child_slots: 5)
       @nonempty = CompleteQuaternaryTree.new(array: @array)
     end
 
     it "must have a size" do
-      @empty.size.must_equal 0
-      @nonempty.size.must_equal @array.size
+      expect(@empty.size).must_equal 0
+      expect(@nonempty.size).must_equal @array.size
     end
 
     it "must have a last_idx, nil when empty" do
-      @empty.last_idx.nil?.must_equal true
-      @nonempty.last_idx.must_equal 99
+      expect(@empty.last_idx.nil?).must_equal true
+      expect(@nonempty.last_idx).must_equal 99
     end
 
     # TODO: push, pop, display

data/test/compsci.rb

@@ -0,0 +1,25 @@
+require 'compsci'
+require 'minitest/autorun'
+
+Minitest::Test.parallelize_me!
+
+describe CompSci do
+  it "must determine if num is a power of base" do
+    powers = {}
+    basemax = 12
+    expmax = 10
+    2.upto(basemax) { |base|
+      0.upto(expmax) { |exp|
+        powers[base] ||= []
+        powers[base] << base**exp
+      }
+    }
+
+    # 12k assertions below!
+    2.upto(basemax) { |base|
+      1.upto(2**expmax) { |num|
+        expect(CompSci.power_of?(num, base)).must_equal powers[base].include?(num)
+      }
+    }
+  end
+end

data/test/fibonacci.rb

@@ -1,6 +1,8 @@
 require 'compsci/fibonacci'
 require 'minitest/autorun'
 
+Minitest::Test.parallelize_me!
+
 include CompSci
 
 describe Fibonacci do
@@ -10,11 +12,10 @@ describe Fibonacci do
 
   it "must calculate fib(0..10)" do
     @answers.each_with_index { |ans, i|
-      Fibonacci.classic(i).must_equal ans
-      Fibonacci.cache_recursive(i).must_equal ans
-      Fibonacci.cache_iterative(i).must_equal ans
-      Fibonacci.dynamic(i).must_equal ans
-      Fibonacci.matrix(i).must_equal ans
+      [:classic, :cache_recursive, :cache_iterative,
+       :dynamic, :matrix].each { |m|
+        expect(Fibonacci.send(m, i)).must_equal ans
+      }
     }
   end
 end

data/test/fit.rb

@@ -1,6 +1,8 @@
 require 'compsci/fit'
 require 'minitest/autorun'
 
+Minitest::Test.parallelize_me!
+
 include CompSci
 
 def noise # range: -0.5 to 0.5
@@ -13,16 +15,18 @@ describe Fit do
   end
 
   describe "Fit.sigma" do
-    it "must answer correctly" do
-      Fit.sigma([1, 2, 3]).must_equal 6
-      Fit.sigma([1, 2, 3]) { |n| n ** 2 }.must_equal 14
+    it "answers correctly" do
+      expect(Fit.sigma([1, 2, 3])).must_equal 6
+      expect(Fit.sigma([1, 2, 3]) { |n| n ** 2 }).must_equal 14
     end
   end
 
   describe "Fit.error" do
-    it "must calculate r^2" do
-      Fit.error([[1, 1], [2, 2], [3, 3]]) { |x| x }.must_equal 1.0
-      Fit.error([[1, 1], [2, 2], [3, 4]]) { |x| x }.must_be_close_to 0.785
+    it "calculates r^2" do
+      expect(Fit.error([[1, 1], [2, 2], [3, 3]]) { |x| x }).must_equal 1.0
+      expect(Fit.error([[1, 1], [2, 2], [3, 4]]) { |x|
+               x
+             }).must_be_close_to 0.785
     end
   end
 
@@ -32,24 +36,24 @@ describe Fit do
   #       alternate measure.  A low slope and r2 for linear fit, maybe.
   #
   describe "Fit.constant" do
-    it "must stuff" do
+    it "returns zero variance with truly constant inputs" do
       [0, 1, 10, 100, 1000, 9999].each { |a|
         y_bar, variance = Fit.constant(@xs, @xs.map { |x| a })
-        y_bar.must_equal a
-        variance.must_equal 0
+        expect(y_bar).must_equal a
+        expect(variance).must_equal 0
       }
     end
   end
 
   # y = a + b*ln(x)
   describe "Fit.logarithmic" do
-    it "must accept logarithmic data" do
+    it "accepts logarithmic data" do
       [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |a|
         [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |b|
           ary = Fit.logarithmic(@xs, @xs.map { |x| a + b * Math.log(x) })
-          ary[0].must_be_close_to a
-          ary[1].must_be_close_to b
-          ary[2].must_equal 1.0
+          expect(ary[0]).must_be_close_to a
+          expect(ary[1]).must_be_close_to b
+          expect(ary[2]).must_equal 1.0
         }
       }
     end
@@ -57,65 +61,63 @@ describe Fit do
 
   # y = a + bx
   describe "Fit.linear" do
-    it "must accept linear data" do
+    it "accepts linear data" do
       [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |a|
         [-9999, -2000, -500, -0.01, 0.01, 500, 2000, 9999].each { |b|
           ary = Fit.linear(@xs, @xs.map { |x| a + b * x })
-          ary[0].must_be_close_to a
-          ary[1].must_be_close_to b
-          ary[2].must_equal 1.0
+          expect(ary[0]).must_be_close_to a
+          expect(ary[1]).must_be_close_to b
+          expect(ary[2]).must_equal 1.0
         }
       }
     end
 
-    it "must accept constant data" do
+    it "accepts constant data" do
       [0, 1, 10, 100, 1000, 9999].each { |a|
         ary = Fit.linear(@xs, @xs.map { |x| a })
-        ary[0].must_equal a
-        ary[1].must_equal 0
-        ary[2].nan?.must_equal true
+        expect(ary[0]).must_equal a
+        expect(ary[1]).must_equal 0
+        expect(ary[2].nan?).must_equal true
       }
     end
 
     # note, this test can possibly fail depending on the uniformity of
     # rand's output for our sample
     #
-    it "must accept noisy constant data" do
+    it "accepts noisy constant data" do
       r2s = []
       [0, 1, 10, 100, 1000, 9999].each { |a|
         ary = Fit.linear(@xs, @xs.map { |x| a + noise() })
-        ary[0].must_be_close_to a, 0.4
-        ary[1].must_be_close_to 0, 0.05
+        expect(ary[0]).must_be_close_to a, 0.4
+        expect(ary[1]).must_be_close_to 0, 0.05
         r2s << ary[2]
       }
       mean_r2 = Fit.sigma(r2s) / r2s.size
-      mean_r2.must_be_close_to 0.15, 0.15
+      expect(mean_r2).must_be_close_to 0.15, 0.15
     end
 
-    it "must reject x^2" do
-      skip "it does not reject x^2 at r^2 < 0.99"
-      xs = [1, 10, 100, 1000]
+    it "rejects x^2" do
+      xs = Array.new(99) { |i| i }
       _a, _b, r2 = Fit.linear(xs, xs.map { |x| x**2 })
-      r2.must_be :<, 0.99
+      expect(r2).must_be :<, 0.99
     end
 
-    it "must reject x^3" do
-      skip "it does not reject x^3 at r^2 < 0.99"
-      xs = [1, 10, 100, 1000]
+    it "rejects x^3" do
+      xs = Array.new(99) { |i| i }
       _a, _b, r2 = Fit.linear(xs, xs.map { |x| x**3 })
-      r2.must_be :<, 0.99
+      expect(r2).must_be :<, 0.99
     end
   end
 
   # y = ae^(bx)
   describe "Fit.exponential" do
-    it "must accept exponential data" do
+    it "accepts exponential data" do
       [0.001, 7.5, 500, 1000, 5000, 9999].each { |a|
         [-1.4, -1.1, -0.1, 0.01, 0.5, 0.75].each { |b|
           ary = Fit.exponential(@xs, @xs.map { |x| a * Math::E**(b * x) })
-          ary[0].must_be_close_to a
-          ary[1].must_be_close_to b
-          ary[2].must_equal 1.0
+          expect(ary[0]).must_be_close_to a
+          expect(ary[1]).must_be_close_to b
+          expect(ary[2]).must_equal 1.0
         }
       }
     end
@@ -123,16 +125,56 @@ describe Fit do
 
   # y = ax^b
   describe "Fit.power" do
-    it "must accept power data" do
+    it "accepts power data" do
       [0.01, 7.5, 500, 1000, 5000, 9999].each { |a|
         [-114, -100, -10, -0.5, -0.1, 0.1, 0.75, 10, 50, 60].each { |b|
-          next if b == -114 # Fit.error warning: Bignum out of Float range
+        # [    -100, -10, -0.5, -0.1, 0.1, 0.75, 10, 50, 60].each { |b|
+          # note: on Ruby 2.4.x and older, b == -114 throws
+          # warning: Bignum out of Float range
+          # also: TruffleRuby as of Jan '22: ary[2] is NaN rather than 1.0
           ary = Fit.power(@xs, @xs.map { |x| a * x**b })
-          ary[0].must_be_close_to a
-          ary[1].must_be_close_to b
-          ary[2].must_equal 1.0
+          expect(ary[0]).must_be_close_to a
+          expect(ary[1]).must_be_close_to b
+          expect(ary[2]).must_equal 1.0
         }
       }
     end
   end
+
+  describe "Fit.predict" do
+    before do
+      @a, @b, @x = 1, 2, 3
+    end
+
+    it "accepts a few different models" do
+      [:constant, :logarithmic, :linear, :exponential, :power].each { |model|
+        expect(Fit.predict(model, @a, @b, @x)).must_be_kind_of(Numeric)
+      }
+      expect { Fit.predict(:invalid, @a, @b, @x) }.must_raise RuntimeError
+    end
+
+    it "predicts constant relationships" do
+      expect(Fit.predict(:constant, @a, @b, @x)).must_equal @a
+      expect(Fit.predict(:constant, @a, @x, @b)).must_equal @a
+      expect(Fit.predict(:constant, @x, @a, @b)).must_equal @x
+    end
+
+    it "predicts logarithmic relationships" do
+      expect(Fit.predict(:logarithmic, @a, @b, @x)
+            ).must_equal @a + @b * Math.log(@x)
+    end
+
+    it "predicts linear relationships" do
+      expect(Fit.predict(:linear, @a, @b, @x)).must_equal @a + @b * @x
+    end
+
+    it "predicts exponential relationships" do
+      expect(Fit.predict(:exponential, @a, @b, @x)
+            ).must_equal @a * Math::E ** (@b * @x)
+    end
+
+    it "predicts power relationships" do
+      expect(Fit.predict(:power, @a, @b, @x)).must_equal @a * @x ** @b
+    end
+  end
 end