compsci 0.3.0.1 → 0.3.1.1

data/lib/compsci/simplex.rb

@@ -1,9 +1,9 @@
-require 'compsci'
-
 # note, this work is based on https://github.com/rickhull/simplex
 # which was forked in 2017 from https://github.com/danlucraft/simplex
 # which had its last commit in 2013
 
+module CompSci; end
+
 class CompSci::Simplex
   DEFAULT_MAX_PIVOTS = 10_000
 
@@ -168,6 +168,4 @@ class CompSci::Simplex
     lines.insert(1, "-"*max_line_length)
     lines.join("\n")
   end
-
-
 end

data/lib/compsci/simplex/parse.rb

@@ -84,16 +84,16 @@ class CompSci::Simplex
 
   def self.problem(maximize: nil, constraints: [], **kwargs)
     if maximize
-      obj, maximize = maximize, true
+      expr, maximize = maximize, true
     elsif kwargs[:minimize]
-      obj, maximize = kwargs[:minimize], false
+      expr, maximize = kwargs[:minimize], false
     else
       raise(ArgumentError, "one of maximize/minimize expected")
     end
-    unless obj.is_a?(String)
+    unless expr.is_a?(String)
       raise(ArgumentError, "bad expr: #{expr} (#{expr.class})")
     end
-    obj_cof = Parse.expression(obj)
+    obj_cof = Parse.expression(expr)
 
     c = [] # coefficients of objective expression
     a = [] # array (per constraint) of the inequality's lhs coefficients

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
@@ -14,15 +16,17 @@ describe Fit do
 
   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
+      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
+      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
 
@@ -35,8 +39,8 @@ describe Fit do
     it "must stuff" 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
@@ -47,9 +51,9 @@ describe Fit 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
@@ -61,9 +65,9 @@ describe Fit 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
@@ -71,9 +75,9 @@ describe Fit do
     it "must accept 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
 
@@ -84,26 +88,26 @@ describe Fit 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]
       _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]
       _a, _b, r2 = Fit.linear(xs, xs.map { |x| x**3 })
-      r2.must_be :<, 0.99
+      expect(r2).must_be :<, 0.99
     end
   end
 
@@ -113,9 +117,9 @@ describe Fit 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
@@ -128,9 +132,9 @@ describe Fit do
         [-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
           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