combinatorics 0.3.0 → 0.4.4

data/spec/cartesian_product/mixin_examples.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+require 'combinatorics/cartesian_product/mixin'
+
+shared_examples_for "CartesianProduct::Mixin" do
+  it "the cartprod of any two Set's should return an Enumerator" do
+    set     = subject[1]
+    results = set.cartprod(set)
+
+    expect(results).to be_kind_of(Enumerator)
+  end
+
+  it "the cartprod of two empty Set's should return an empty Set" do
+    set     = subject[]
+    results = set.cartprod([]).to_a
+    
+    expect(results).to be_empty
+  end
+
+  it "the cartprod of a single empty set should return an empty Set" do
+    set     = subject[1,2]
+    results = set.cartprod([2,3],[]).to_a
+    
+    expect(results).to be_empty
+  end
+
+  it "the cartprod of another empty set should also return an empty Set" do
+    set     = subject[]
+    results = set.cartprod([1]).to_a
+    
+    expect(results).to be_empty
+  end
+
+  it "the cartprod of [1] and [1] should be [[1, 1]]" do
+    set     = subject[1]
+    results = set.cartprod([1]).to_a
+    
+    expect(results).to eq([[1, 1]])
+  end
+
+  it "the cartprod of [1, 2] and [3] should be [[1, 3], [2, 3]]" do
+    set     = subject[1, 2]
+    results = set.cartprod([3]).to_a
+    
+    expect(results).to match_array([[1, 3], [2, 3]])
+  end
+
+  it "the cartprod of [1, 2] and [3, 4] should be [[1, 3], [1, 4], [2, 3], [2, 4]]" do
+    set     = subject[1, 2]
+    results = set.cartprod([3, 4]).to_a
+    
+    expect(results).to match_array([
+      [1, 3], [1, 4],
+      [2, 3], [2, 4]
+    ])
+  end
+
+  it "the cartprod of ['a'].cartprod(['b', 'c', 'd']) should be [['a', 'b'], ['a', 'c'], ['a', 'd']]" do
+    set1    = subject['a']
+    set2    = subject['b', 'c', 'd']
+    results = set1.cartprod(set2).to_a
+    
+    expect(results).to match_array([['a', 'b'], ['a', 'c'], ['a', 'd']])
+  end
+
+  it "the cartprod of [0, 1] and [[2, 3], [4, 5]] should be [[0, 2, 4], [1, 2, 4], [0, 3, 4], [1, 3, 4], [0, 2, 5], [1, 2, 5], [0, 3, 5], [1, 3, 5]]" do
+    set1    = subject[0, 1]
+    set2    = subject[2, 3]
+    set3    = subject[4, 5]
+    results = set1.cartprod(set2, set3).to_a
+    
+    expect(results).to match_array([
+      [0, 2, 4], [0, 2, 5], [0, 3, 4], [0, 3, 5],
+      [1, 2, 4], [1, 2, 5], [1, 3, 4], [1, 3, 5],
+    ])
+  end
+
+  it "should take an optional block argument" do
+    set     = subject[1]
+    results = []
+
+    set.cartprod(set) { |result| results << result }
+
+    expect(results).to eq([[1, 1]])
+  end
+
+  it "should alias cartprod to cartesian_product" do
+    aset = subject[1]
+
+    expect(aset).to respond_to(:cartesian_product)
+  end
+
+  it "should alias cartprod to cartesian" do
+    aset = subject[1]
+
+    expect(aset).to respond_to(:cartesian)
+  end
+end

data/spec/cartesian_product/set_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'cartesian_product/mixin_examples'
+
+require 'combinatorics/cartesian_product/extensions/set'
+
+describe Set do
+  subject { Set }
+
+  it_should_behave_like "CartesianProduct::Mixin"
+end

data/spec/choose/array_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'combinatorics/choose/extensions/array'
+require 'choose/mixin_examples'
+
+describe Array do
+  subject { Array }
+
+  it_should_behave_like 'Choose::Mixin'
+end

data/spec/choose/cardinality_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'combinatorics/choose'
+
+describe Choose do
+  subject { Choose }
+
+  describe "cardinality" do
+    it "should raise RangeError if n is negative" do
+      expect { subject.cardinality(-1) }.to raise_error(RangeError)
+    end
+
+    it "should raise RangeError if n is negative" do
+      expect { subject.cardinality(-1, 1) }.to raise_error(RangeError)
+    end
+
+    it "should raise RangeError if r is negative" do
+      expect { subject.cardinality(1, -1) }.to raise_error(RangeError)
+    end
+
+    it "should raise RangeError if r is greater than n" do
+      expect { subject.cardinality(2, 3) }.to raise_error(RangeError)
+    end
+
+    it "should return 1 for subject.cardinality(0)" do
+      expect(subject.cardinality(0)).to eq(1)
+    end
+
+    it "should return 1 for subject.cardinality(1)" do
+      expect(subject.cardinality(1)).to eq(1)
+    end
+
+    it "should return 2 for subject.cardinality(2)" do
+      expect(subject.cardinality(2)).to eq(2)
+    end
+
+    it "should return 6 for subject.cardinality(3)" do
+      expect(subject.cardinality(3)).to eq(6)
+    end
+
+    it "should return 24 for subject.cardinality(4)" do
+      expect(subject.cardinality(4)).to eq(24)
+    end
+
+    it "should return 1 for subject.cardinality(1, 0)" do
+      expect(subject.cardinality(1, 0)).to eq(1)
+    end
+
+    it "should return 1 for subject.cardinality(1, 1)" do
+      expect(subject.cardinality(1, 1)).to eq(1)
+    end
+
+    it "should return 2 for subject.cardinality(2, 1)" do
+      expect(subject.cardinality(2, 1)).to eq(2)
+    end
+
+    it "should return 1 for subject.cardinality(2, 2)" do
+      expect(subject.cardinality(2, 2)).to eq(1)
+    end
+
+    it "should return 3 for subject.cardinality(3, 1)" do
+      expect(subject.cardinality(3, 1)).to eq(3)
+    end
+
+    it "should return 3 for subject.cardinality(3, 2)" do
+      expect(subject.cardinality(3, 2)).to eq(3)
+    end
+
+    it "should return 1 for subject.cardinality(3, 3)" do
+      expect(subject.cardinality(3, 3)).to eq(1)
+    end
+
+    it "should return 4 for subject.cardinality(4, 1)" do
+      expect(subject.cardinality(4, 1)).to eq(4)
+    end
+
+    it "should return 6 for subject.cardinality(4, 2)" do
+      expect(subject.cardinality(4, 2)).to eq(6)
+    end
+
+    it "should return 4 for subject.cardinality(4, 3)" do
+      expect(subject.cardinality(4, 3)).to eq(4)
+    end
+
+    it "should return 1 for subject.cardinality(4, 4)" do
+      expect(subject.cardinality(4, 4)).to eq(1)
+    end
+
+    it "should return 15 for subject.cardinality(6, 4)" do
+      expect(subject.cardinality(6, 4)).to eq(15)
+    end
+
+    it "should return 3628800 for subject.cardinality(10)" do
+      expect(subject.cardinality(10)).to eq(3628800)
+    end
+  end
+
+  describe "cardinality_all" do
+    it "should return [] for subject.cardinality_all(0)" do
+      expect(subject.cardinality_all(0)).to be_empty
+    end
+
+    it "should return [1] for subject.cardinality_all(1)" do
+      expect(subject.cardinality_all(1)).to eq([1])
+    end
+
+    it "should return [2, 1] for subject.cardinality_all(2)" do
+      expect(subject.cardinality_all(2)).to eq([2, 1])
+    end
+
+    it "should return [3, 3, 1] for subject.cardinality_all(3)" do
+      expect(subject.cardinality_all(3)).to eq([3, 3, 1])
+    end
+
+    it "should return [4, 6, 4, 1] for subject.cardinality_all(4)" do
+      expect(subject.cardinality_all(4)).to eq([4, 6, 4, 1])
+    end
+
+    it "should allow specifying the range of `r` values" do
+      expect(subject.cardinality_all(10,5..10)).to eq([
+        252, 210, 120, 45, 10, 1
+      ])
+    end
+
+    it "should raise RangeError for subject.cardinality_all(-1)" do
+      expect { subject.cardinality_all(-1) }.to raise_error(RangeError)
+    end
+
+    it "should wrap cardinality with Choose.C" do
+      should respond_to(:C)
+    end
+  end
+end

data/spec/choose/mixin_examples.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'combinatorics/choose'
+
+shared_examples_for "Choose::Mixin" do
+  let(:empty_set) { Set[] }
+
+  it "should return [[]] for [].choose(0).to_a" do
+    set     = subject[]
+    results = set.choose(0).to_a
+
+    expect(results).to eq([empty_set])
+  end
+
+  it "should return [[]] for [1].choose(0).to_a" do
+    set     = subject[1]
+    results = set.choose(0).to_a
+    
+    expect(results).to eq([empty_set])
+  end
+
+  it "should return [[1]] for [1].choose(1).to_a" do
+    set     = subject[1]
+    results = set.choose(1).to_a
+    
+    expect(results).to eq([Set[1]])
+  end
+
+  it "should return [[1], [2]] for [1, 2].choose(1).to_a" do
+    set     = subject[1, 2]
+    results = set.choose(1).to_a
+    
+    expect(results).to match_array([Set[1], Set[2]])
+  end
+
+  it "should return [[1, 2]] for [1, 2].choose(2).to_a" do
+    set     = subject[1, 2]
+    results = set.choose(2).to_a
+    
+    expect(results).to eq([Set[1, 2]])
+  end
+
+  it "should filter out repeated elements" do
+    set1 = subject[1,1,2,3]
+    set2 = subject[1,2,3]
+
+    expect(set1.choose(2).to_a).to eq(set2.choose(2).to_a)
+  end
+end

data/spec/choose/set_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'combinatorics/choose/extensions/set'
+require 'choose/mixin_examples'
+
+describe Set do
+  subject { Set }
+
+  it_should_behave_like 'Choose::Mixin'
+end

data/spec/combinatorics_spec.rb

@@ -1,4 +1,8 @@
 require 'spec_helper'
+require 'combinatorics/version'
 
-describe "Combinatorics" do
+describe Combinatorics do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).not_to be_empty
+  end
 end

data/spec/derange/array_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'derange/mixin_examples'
+
+require 'combinatorics/derange/extensions/array'
+
+describe Array do
+  subject { Array }
+
+  it_should_behave_like "Derange::Mixin"
+end

data/spec/derange/cardinality_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'combinatorics/derange/cardinality'
+
+describe Derange do
+  subject { Derange }
+
+  it "should alias cardinality to subfactorial" do
+    should respond_to(:cardinality)
+  end
+
+  it "should wrap subfactorial with Derange.D" do
+    should respond_to(:D)
+  end
+end

data/spec/derange/mixin_examples.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+require 'combinatorics/derange'
+
+shared_examples_for "Derange::Mixin" do
+  it "the derange of an empty Set should only contain an empty Array" do
+    set     = subject[]
+    results = set.derange.to_a
+    
+    expect(results).to eq([[]])
+  end
+
+  it "should return [[]] for [1].derange.to_a" do
+    set     = subject[1]
+    results = set.derange.to_a
+
+    expect(results).to eq([[]])
+  end
+
+  it "should return [[2, 1]] for [1, 2].derange.to_a" do
+    set     = subject[1, 2]
+    results = set.derange.to_a
+
+    expect(results).to eq([[2, 1]])
+  end
+
+  it "should return [[2, 1, 4, 3], [2, 3, 4, 1], [2, 4, 1, 3], [3, 1, 4, 2], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 3, 1, 2], [4, 3, 2, 1]] for [1, 2, 3, 4].derange.to_a" do
+    set     = [1, 2, 3, 4]
+    results = set.derange.to_a
+    
+    expect(results).to eq([
+      [2, 1, 4, 3],
+      [2, 3, 4, 1],
+      [2, 4, 1, 3],
+      [3, 1, 4, 2],
+      [3, 4, 1, 2],
+      [3, 4, 2, 1],
+      [4, 1, 2, 3],
+      [4, 3, 1, 2],
+      [4, 3, 2, 1]
+    ])
+  end
+
+  it "should take an optional block argument" do
+    set     = subject[1, 2, 3]
+    results = []
+
+    set.derange { |deranged| results << deranged }
+
+    expect(results).to eq([[2, 3, 1], [3, 1, 2]])
+  end
+end

data/spec/enumerator_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/enumerator'
 
 describe Combinatorics::Enumerator do
   it "should auto-detect the Enumerator class" do
-    Combinatorics::Enumerator.should_not be_nil
+    expect(Combinatorics::Enumerator).not_to be_nil
   end
 end

data/spec/extensions/math_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'combinatorics/extensions/math'
+
+describe Math do
+  it "should alias Sigma to sigma" do
+    should respond_to(:Sigma)
+  end
+
+  it "should alias Pi to pi" do
+    should respond_to(:Pi)
+  end
+
+  describe "sigma" do
+    it "should return 6 for sigma(1..3)" do
+      expect(subject.sigma(1..3)).to eq(6)
+    end
+
+    it "should return 60 for sigma(3..5)" do
+      expect(subject.sigma(3..5)).to eq(12)
+    end
+
+    it "should take an optional block argument" do
+      result = subject.sigma(1..5) { |i| i * 2 }
+
+      expect(result).to eq((1 * 2) + (2 * 2) + (3 * 2) + (4 * 2) + (5 * 2))
+    end
+  end
+
+  describe "pi" do
+    it "should return 24 for pi(1..4)" do
+      expect(subject.pi(1..4)).to eq(24)
+    end
+
+    it "should return 30 for pi(5..6)" do
+      expect(subject.pi(5..6)).to eq(30)
+    end
+
+    it "should take an optional block argument" do
+      result = subject.pi(1..3) { |i| i * 2 }
+
+      expect(result).to eq((1 * 2) * (2 * 2) * (3 * 2))
+    end
+  end
+
+  describe "factorial" do
+    it "should return 1 for factorial(0)" do
+      expect(subject.factorial(0)).to eq(1)
+    end
+
+    it "should return 1 for factorial(1)" do
+      expect(subject.factorial(1)).to eq(1)
+    end
+
+    it "should return 2 for factorial(2)" do
+      expect(subject.factorial(2)).to eq(2)
+    end
+
+    it "should return 6 for factorial(3)" do
+      expect(subject.factorial(3)).to eq(6)
+    end
+    
+    it "should return 3628800 for factorial(10)" do
+      expect(subject.factorial(10)).to eq(3628800)
+    end
+
+    it "should raise RangeError for factorial(-1)" do
+      expect { subject.factorial(-1) }.to raise_error(RangeError)
+    end
+  end
+
+  describe "subfactorial" do
+    it "should return 1 for subfactorial(0)" do
+      expect(subject.subfactorial(0)).to eq(1)
+    end
+
+    it "should return 0 for subfactorial(1)" do
+      expect(subject.subfactorial(1)).to eq(0)
+    end
+
+    it "should return 1 for subfactorial(2)" do
+      expect(subject.subfactorial(2)).to eq(1)
+    end
+
+    it "should return 2 for subfactorial(3)" do
+      expect(subject.subfactorial(3)).to eq(2)
+    end
+
+    it "should return 9 for subfactorial(4)" do
+      expect(subject.subfactorial(4)).to eq(9)
+    end
+
+    it "should return 44 for subfactorial(5)" do
+      expect(subject.subfactorial(5)).to eq(44)
+    end
+
+    it "should raise RangeError for subfactorial(-1)" do
+      expect { subject.subfactorial(-1) }.to raise_error(RangeError)
+    end
+  end
+end

data/spec/extensions/range_spec.rb

@@ -4,11 +4,11 @@ require 'combinatorics/extensions/range'
 describe Range do
   describe "&" do
     it "should pick the maximum beginning value" do
-      ((100..200) & (150..200)).first.should == 150
+      expect(((100..200) & (150..200)).first).to eq(150)
     end
 
-    it "should pick the mimum ending value" do
-      ((100..150) & (100..200)).last.should == 150
+    it "should pick the minimum ending value" do
+      expect(((100..150) & (100..200)).last).to eq(150)
     end
   end
 
@@ -16,28 +16,28 @@ describe Range do
     subject { 1..10 }
 
     it "should iterate over every beginning value" do
-      subject.upto(5..10).to_a.should == [
+      expect(subject.upto(5..10).to_a).to eq([
         (1..10),
         (2..10),
         (3..10),
         (4..10),
         (5..10)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.upto(1..15).to_a.should == [
+      expect(subject.upto(1..15).to_a).to eq([
         (1..10),
         (1..11),
         (1..12),
         (1..13),
         (1..14),
         (1..15)
-      ]
+      ])
     end
 
     it "should not iterate up to lower bounding ranges" do
-      subject.upto(0..5).to_a.should be_empty
+      expect(subject.upto(0..5).to_a).to be_empty
     end
   end
 
@@ -45,28 +45,28 @@ describe Range do
     subject { 5..15 }
 
     it "should iterate over every beginning value" do
-      subject.downto(1..15).to_a.should == [
+      expect(subject.downto(1..15).to_a).to eq([
         (5..15),
         (4..15),
         (3..15),
         (2..15),
         (1..15)
-      ]
+      ])
     end
 
     it "should iterate over every ending value" do
-      subject.downto(5..10).to_a.should == [
+      expect(subject.downto(5..10).to_a).to eq([
         (5..15),
         (5..14),
         (5..13),
         (5..12),
         (5..11),
         (5..10)
-      ]
+      ])
     end
 
     it "should not iterate down to upward bounding ranges" do
-      subject.downto(10..20).to_a.should be_empty
+      expect(subject.downto(10..20).to_a).to be_empty
     end
   end
 end

data/spec/generator_spec.rb

@@ -3,6 +3,6 @@ require 'combinatorics/generator'
 
 describe Combinatorics::Generator do
   it "should auto-detect the Generator class" do
-    Combinatorics::Generator.should_not be_nil
+    expect(Combinatorics::Generator).not_to be_nil
   end
 end

data/spec/list_comprehension_spec.rb

@@ -6,46 +6,46 @@ describe "Array#comprehension" do
   it "should return an Enumerator object if no block is given" do
     a = [1..5]
 
-    a.comprehension.should_not be_kind_of(Array)
+    expect(a.comprehension).not_to be_kind_of(Array)
   end
 
   it "should yield iterations to the given block" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should do nothing an Array of all non-enumerable objects" do
     a = [1,2,3]
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should pass through an empty Array" do
     a = []
 
-    a.comprehension.to_a.should == [a]
+    expect(a.comprehension.to_a).to eq([a])
   end
 
   it "should iterate over the values within an enumerable value" do
     range = (1..5)
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[4],[5]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[4],[5]])
   end
 
   it "should iterate over repeating values" do
     range = [1,2,3,1,2,4]
     a = [range]
 
-    a.comprehension.to_a.should == [[1],[2],[3],[1],[2],[4]]
+    expect(a.comprehension.to_a).to eq([[1],[2],[3],[1],[2],[4]])
   end
 
   it "should iterate over values from a generator" do
     a = [Combinatorics::Generator.new { |g| 5.times { |i| g.yield i } }]
 
-    a.comprehension.to_a.should == [[0],[1],[2],[3],[4]]
+    expect(a.comprehension.to_a).to eq([[0],[1],[2],[3],[4]])
   end
 
   it "should iterate over values from a non-repeating generator" do
@@ -54,20 +54,20 @@ describe "Array#comprehension" do
       [1,2],
       Combinatorics::Generator.new { |g|
         multiplier += 1
-        5.times { |i| g.yield (i * multiplier) }
+        5.times { |i| g.yield(i * multiplier) }
       }
     ]
 
-    a.comprehension.to_a.should == [
+    expect(a.comprehension.to_a).to eq([
       [1,0],[1,1],[1,2],[1,3],[1,4],
       [2,0],[2,2],[2,4],[2,6],[2,8]
-    ]
+    ])
   end
 
   it "should ignore non-enumerable values" do
     range = (1..5)
     a = [1,range]
 
-    a.comprehension.to_a.should == [[1,1],[1,2],[1,3],[1,4],[1,5]]
+    expect(a.comprehension.to_a).to eq([[1,1],[1,2],[1,3],[1,4],[1,5]])
   end
 end

data/spec/permute/array_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'permute/mixin_examples'
+
+require 'combinatorics/permute/extensions/array'
+
+describe Array do
+  subject { Array }
+
+  it_should_behave_like "Permute::Mixin"
+end