compsci 0.1.1.1 → 0.2.0.1

data/test/simplex.rb

@@ -0,0 +1,291 @@
+require 'minitest/autorun'
+require 'compsci/simplex'
+
+include CompSci
+
+class SimplexTest < Minitest::Test
+  def test_2x2
+    result = Simplex.new(
+      [1, 1],
+      [
+        [ 2,  1],
+        [ 1,  2],
+      ],
+      [4, 3]
+    ).solution
+    assert_equal [Rational(5, 3), Rational(2, 3)], result
+  end
+
+  def test_2x2_b
+    result = Simplex.new(
+      [3, 4],
+      [
+        [ 1,  1],
+        [ 2,  1],
+      ],
+      [4, 5]
+    ).solution
+    assert_equal [0, 4], result
+  end
+
+  def test_2x2_c
+    result = Simplex.new(
+      [2, -1],
+      [
+        [ 1,  2],
+        [ 3,  2],
+      ],
+      [6, 12]
+    ).solution
+    assert_equal [4, 0], result
+  end
+
+  def test_3x3_a
+    result = Simplex.new(
+      [60, 90, 300],
+      [
+        [1, 1, 1],
+        [1, 3, 0],
+        [2, 0, 1]
+      ],
+      [600, 600, 900]
+    ).solution
+    assert_equal [0, 0, 600], result
+  end
+
+  def test_3x3_b
+    result = Simplex.new(
+      [70, 210, 140],
+      [
+        [ 1,  1,  1],
+        [ 5,  4,  4],
+        [40, 20, 30]
+      ],
+      [100, 480, 3200]
+    ).solution
+    assert_equal [0, 100, 0], result
+  end
+
+  def test_3x3_c
+    result = Simplex.new(
+      [2, -1, 2],
+      [
+        [ 2,  1,  0],
+        [ 1,  2, -2],
+        [ 0,  1,  2]
+      ],
+      [10, 20, 5]
+    ).solution
+    assert_equal [5, 0, Rational(5, 2)], result
+  end
+
+  def test_3x3_d
+    result = Simplex.new(
+      [11, 16, 15],
+      [
+        [             1,              2, Rational(3, 2)],
+        [Rational(2, 3), Rational(2, 3),              1],
+        [Rational(1, 2), Rational(1, 3), Rational(1, 2)]
+      ],
+      [12_000, 4_600, 2_400]
+    ).solution
+    assert_equal [600, 5_100, 800], result
+  end
+
+  def test_3x3_e
+    simplex = Simplex.new(
+      [5, 4, 3],
+      [
+        [2, 3, 1],
+        [4, 1, 2],
+        [3, 4, 2]
+      ],
+      [5, 11, 8]
+    )
+    assert_equal [2, 0, 1], simplex.solution
+  end
+
+  def test_3x3_f
+    simplex = Simplex.new(
+      [3, 2, -4],
+      [
+        [1, 4, 0],
+        [2, 4,-2],
+        [1, 1,-2]
+      ],
+      [5, 6, 2]
+    )
+    assert_equal [4, 0, 1], simplex.solution
+  end
+
+  def test_3x3_g
+    simplex = Simplex.new(
+      [2, -1, 8],
+      [
+        [2, -4, 6],
+        [-1, 3, 4],
+        [0, 0, 2]
+      ],
+      [3, 2, 1]
+    )
+    assert_equal [Rational(17, 2), Rational(7,2), 0], simplex.solution
+  end
+
+  def test_3x4
+    result = Simplex.new(
+      [100_000, 40_000, 18_000],
+      [
+        [20, 6, 3],
+        [ 0, 1, 0],
+        [-1,-1, 1],
+        [-9, 1, 1]
+      ],
+      [182, 10, 0, 0]
+    ).solution
+    assert_equal [4, 10, 14], result
+  end
+
+  def test_4x4
+    result = Simplex.new(
+      [1, 2, 1, 2],
+      [
+        [1, 0, 1, 0],
+        [0, 1, 0, 1],
+        [1, 1, 0, 0],
+        [0, 0, 1, 1]
+      ],
+      [1, 4, 2, 2]
+    ).solution
+    assert_equal [0, 2, 0, 2], result
+  end
+
+  def test_cycle
+    result = Simplex.new(
+      [10, -57, -9, -24],
+      [
+        [0.5, -5.5, -2.5, 9],
+        [0.5, -1.5, -0.5, 1],
+        [  1,    0,    0, 0]
+      ],
+      [0, 0, 1]
+    ).solution
+    assert_equal [1, 0, 1, 0], result
+  end
+
+  def test_cycle2
+    simplex = Simplex.new(
+      [2, 3, -1, -12],
+      [
+        [-2, -9, 1, 9],
+        [Rational(1, 3), 1, Rational(-1, 3), -2],
+      ],
+      [0, 0]
+    )
+    assert_raises Simplex::UnboundedProblem do
+      simplex.solution
+    end
+  end
+
+  def test_error_mismatched_dimensions
+    assert_raises ArgumentError do
+      Simplex.new(
+        [10, -57, -9],
+        [
+          [0.5, -5.5, -2.5, 9],
+          [0.5, -1.5, -0.5, 1],
+          [  1,    0,    0, 0]
+        ],
+        [0, 0, 1]
+      )
+    end
+
+    assert_raises ArgumentError do
+      Simplex.new(
+        [10, -57, -9, 2],
+        [
+          [0.5, -5.5, 9, 4],
+          [0.5, -1.5, 1],
+          [  1,    0, 0]
+        ],
+        [0, 0, 1]
+      )
+    end
+
+    assert_raises ArgumentError do
+      Simplex.new(
+        [10, -57, -9, 2],
+        [
+          [0.5, -5.5, 9, 4],
+          [0.5, -1.5, 1, 5],
+          [  1,    0, 0, 5]
+        ],
+        [0, 1]
+      )
+    end
+  end
+
+  def test_manual_iteration
+    simplex = Simplex.new(
+      [10, -57, -9, -24],
+      [
+        [0.5, -5.5, -2.5, 9],
+        [0.5, -1.5, -0.5, 1],
+        [  1,    0,    0, 0]
+      ],
+      [0, 0, 1]
+    )
+    while simplex.can_improve?
+      assert simplex.formatted_tableau.is_a?(String)
+      simplex.pivot
+    end
+    result = simplex.solution
+    assert_equal [1, 0, 1, 0], result
+  end
+
+  def test_cup_factory
+    result = Simplex.new(
+      [25, 20],
+      [
+        [20, 12],
+        [1, 1]
+      ],
+      [1800, 8*15]
+    )
+    assert_equal [45, 75], result.solution
+  end
+
+  #def test_infeasible1
+  #  simplex = Simplex.new(
+  #    [2, -1],
+  #    [
+  #      [1, -1],
+  #      [-1, 1]
+  #    ],
+  #    [1, -2]
+  #  )
+  #  while simplex.can_improve?
+  #    puts
+  #    puts simplex.formatted_tableau
+  #    simplex.pivot
+  #  end
+  #  p :done
+  #  puts
+  #  puts simplex.formatted_tableau
+
+  #end
+
+  def test_unbounded
+    simplex = Simplex.new(
+      [1, 1, 1],
+      [
+        [3, 1, -2],
+        [4, 3, 0]
+      ],
+      [5, 7]
+    )
+    assert_raises Simplex::UnboundedProblem do
+      simplex.solution
+    end
+  end
+
+end

data/test/simplex_parse.rb

@@ -0,0 +1,94 @@
+require 'compsci/simplex/parse'
+require 'minitest/autorun'
+
+include CompSci
+
+describe Simplex::Parse do
+  P = Simplex::Parse
+
+  describe "Parse.term" do
+    it "must parse valid terms" do
+      { "-1.2A" => [-1.2, :A],
+        "99x"   => [99.0, :x],
+        "z"     => [ 1.0, :z],
+        "-b"    => [-1.0, :b] }.each { |valid, expected|
+        P.term(valid).must_equal expected
+      }
+    end
+
+    it "must reject invalid terms" do
+      ["3xy", "24/7x", "x17", "2*x"].each { |invalid|
+        proc { P.term(invalid) }.must_raise RuntimeError
+      }
+    end
+  end
+
+  describe "Parse.expression" do
+    it "must parse valid expressions" do
+      { "x + y"             => { x:  1.0, y:  1.0 },
+        "2x - 5y"           => { x:  2.0, y: -5.0 },
+        "-2x - 3y + -42.7z" => { x: -2.0, y: -3.0, z: -42.7 },
+        " -5y + -x  "       => { y: -5.0, x: -1.0 },
+        "a - -b"            => { a:  1.0, b:  1.0 },
+        "a A b"             => { a:  1.0, :A => 1.0, b: 1.0 },
+      }.each { |valid, expected|
+        P.expression(valid).must_equal expected
+      }
+    end
+
+    it "must reject invalid expressions" do
+      ["a2 + b2 = c2",
+       "x + xy",
+       "x * 2"].each { |invalid|
+        proc { P.expression(invalid) }.must_raise P::Error
+      }
+    end
+  end
+
+  describe "Parse.tokenize" do
+    it "ignores leading or trailing whitespace" do
+      P.tokenize("  5x + 2.9y ").must_equal ["5x", "+", "2.9y"]
+    end
+
+    it "ignores multiple spaces" do
+      P.tokenize("5x   +   2.9y").must_equal ["5x", "+", "2.9y"]
+    end
+  end
+
+  describe "Parse.inequality" do
+    it "must parse valid inequalities" do
+      { "x + y <= 4"              => [{ x: 1.0, y: 1.0 }, 4.0],
+        "0.94a - 22.1b <= -14.67" => [{ a: 0.94, b: -22.1 }, -14.67],
+        "x <= 0"                  => [{ x: 1.0 }, 0],
+      }.each { |valid, expected|
+        P.inequality(valid).must_equal expected
+      }
+    end
+
+    it "must reject invalid inequalities" do
+      ["x + y >= 4",
+       "0.94a - 22.1b <= -14.67c",
+       "x < 0",
+      ].each { |invalid|
+        proc { P.inequality(invalid) }.must_raise P::Error
+      }
+    end
+  end
+end
+
+describe "Simplex.maximize" do
+  it "must problem stuff" do
+    prob = Simplex.problem(maximize: 'x + y',
+                           constraints: ['2x + y <= 4',
+                                         'x + 2y <= 3'])
+    sol = prob.solution
+    sol.must_equal [Rational(5, 3), Rational(2, 3)]
+  end
+
+  it "must maximize stuff" do
+    Simplex.maximize('x + y',
+                     '2x + y <= 4',
+                     'x + 2y <= 3').must_equal [Rational(5, 3),
+                                                Rational(2, 3)]
+  end
+end

data/test/tree.rb

@@ -1,3 +1,4 @@
+require 'compsci/node'
 require 'compsci/tree'
 require 'minitest/autorun'
 
@@ -5,7 +6,7 @@ include CompSci
 
 describe Tree do
   before do
-    @tree = Tree.new(Node, 42)
+    @tree = Tree.new(FlexNode, 42)
     @vals = Array.new(99) { rand 99 }
   end
 
@@ -16,7 +17,7 @@ describe Tree do
 
   it "does depth_first search" do
     vals = (0..30).to_a
-    tree = Tree.new(Node, vals.shift)
+    tree = Tree.new(FlexNode, vals.shift)
     tree.root.new_child vals.shift
     tree.root.new_child vals.shift
     tree.root.children.each { |c|
@@ -40,7 +41,7 @@ describe Tree do
 
   it "does breadth_first search" do
     vals = (0..30).to_a
-    tree = Tree.new(Node, vals.shift)
+    tree = Tree.new(FlexNode, vals.shift)
     tree.root.new_child vals.shift
     tree.root.new_child vals.shift
     tree.root.children.each { |c|
@@ -64,9 +65,32 @@ describe Tree do
 end
 
 describe NaryTree do
-  describe "with Node" do
+  it "must power_of?" 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|
+        if powers[base].include?(num)
+          NaryTree.power_of?(num, base).must_equal true
+        else
+          NaryTree.power_of?(num, base).must_equal false
+        end
+      }
+    }
+  end
+
+  describe "with FlexNode" do
     before do
-      @tree = NaryTree.new(Node, 42, child_slots: 3)
+      @tree = NaryTree.new(FlexNode, 42, child_slots: 3)
     end
 
     it "must have an open parent" do
@@ -82,9 +106,9 @@ describe NaryTree do
     end
   end
 
-  describe "with ChildNode" do
+  describe "with ChildFlexNode" do
     before do
-      @tree = NaryTree.new(ChildNode, 42, child_slots: 4)
+      @tree = NaryTree.new(ChildFlexNode, 42, child_slots: 4)
     end
 
     it "must have an open parent" do
@@ -103,7 +127,7 @@ end
 
 describe "BinaryTree" do
   before do
-    @tree = BinaryTree.new(Node, 42)
+    @tree = BinaryTree.new(FlexNode, 42)
   end
 
   it "must have 2 child_slots" do
@@ -121,7 +145,7 @@ describe "BinaryTree" do
 
   describe "searching" do
     before do
-      @tree = NaryTree.new(Node, 42, child_slots: 2)
+      @tree = NaryTree.new(FlexNode, 42, child_slots: 2)
       99.times { |i| @tree.push i }
     end