gecoder-with-gecode 0.8.2 → 0.8.3

data/specs/constraints/bool_enum_relation.rb

@@ -15,8 +15,8 @@ class BoolEnumSampleProblem < Gecode::Model
   end
 end
 
-# Expects @stub, which contains the started constraint and @compute_result which 
-# computes whether the left hand side is true or not.
+# Expects @stub, which contains the started constraint and @compute_result 
+# which computes whether the left hand side is true or not.
 describe 'bool enum relation constraint', :shared => true do
   it 'should handle being constrained to be true' do
     @stub.must_be.true
@@ -76,7 +76,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (conjunction)' do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      @bools.conjunction.must_be.equal_to(true, hash) 
+      @bools.conjunction.must.equal(@b1, hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
@@ -94,7 +94,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (conjunction)' do
             an_instance_of(Gecode::Raw::BoolVar),
             anything,
             an_instance_of(Gecode::Raw::BoolVar),
-            anything, anything, anything)
+            anything, anything)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             Gecode::Raw::BOT_AND, 
@@ -122,7 +122,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (disjunction)' do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      @bools.disjunction.must_be.equal_to(true, hash) 
+      @bools.disjunction.must.equal(@b1, hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
@@ -140,7 +140,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (disjunction)' do
             an_instance_of(Gecode::Raw::BoolVar),
             anything,
             an_instance_of(Gecode::Raw::BoolVar),
-            anything, anything, anything)          
+            anything, anything)          
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             Gecode::Raw::BOT_OR, 

data/specs/constraints/boolean.rb

@@ -22,28 +22,22 @@ describe Gecode::Constraints::Bool do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      (@b1 | @b2).must_be.equal_to(true, hash) 
+      (@b1 | @b2).must_be.true(hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::BoolVar),
-          Gecode::Raw::BOT_OR, 
-          an_instance_of(Gecode::Raw::BoolVar), 
-          an_instance_of(Gecode::Raw::BoolVar),
-          Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
+        # We only test the non-MiniModel parts.
         unless reif_var.nil?
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::BOT_EQV, 
-            an_instance_of(Gecode::Raw::BoolVar), 1, strength, kind)
+            an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::IRT_EQ, 
+            an_instance_of(Gecode::Raw::BoolVar), strength, kind)
         end
       end
     end
   end
-  
+
   it 'should handle single variables constrainted to be true' do
     @b1.must_be.true
     b1 = @model.solve!.b1
@@ -79,7 +73,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should be_true
   end
-  
+
   it 'should handle negated disjunction' do
     @b1.must_be.false
     (@b1 | @b2).must_not_be.true
@@ -87,7 +81,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle conjunction' do
     (@b1 & @b2).must_be.true
     sol = @model.solve!
@@ -142,7 +136,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle imply after must_not' do
     @b1.must_be.true
     @b1.must_not.imply @b2
@@ -166,7 +160,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle expressions as right hand side' do
     @b1.must == (@b2 | @b3)
     @b2.must_be.true
@@ -174,7 +168,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should be_true
     sol.b2.value.should be_true
   end
-  
+
   it 'should handle nested expressions as left hand side' do
     ((@b1 & @b2) | @b3 | (@b1 & @b3)).must_be.true
     @b1.must_be.false
@@ -182,7 +176,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b3.value.should be_true
   end
-  
+
   it 'should handle nested expressions on both side' do
     ((@b1 & @b1) | @b3).must == ((@b1 & @b3) & @b2)
     @b1.must_be.true
@@ -191,7 +185,15 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should be_true
     sol.b3.value.should be_true
   end
-  
+
+  it 'should handle nested expressions with implication' do
+    ((@b1 & @b1) | @b3).must.imply(@b1 ^ @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_false
+  end
+
   it 'should handle nested expressions containing exclusive or' do
     ((@b1 ^ @b1) & @b3).must == ((@b2 | @b3) ^ @b2)
     @b1.must_be.true
@@ -201,7 +203,7 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should_not be_true
     sol.b3.value.should_not be_true
   end
-  
+
   it 'should handle nested expressions on both sides with negation' do
     ((@b1 & @b1) | @b3).must_not == ((@b1 | @b3) & @b2)
     @b1.must_be.true
@@ -211,7 +213,7 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should_not be_true
     sol.b3.value.should be_true
   end
-  
+
   it 'should translate reification with a variable right hand side' do
     @b1.must_be.equal_to(@b2, :reify => @b3)
     @b1.must_be.true
@@ -219,8 +221,8 @@ describe Gecode::Constraints::Bool do
     sol = @model.solve!
     sol.b3.value.should_not be_true
   end
-  
-  it 'should translate reification with a variable right hand side and negation' do
+
+  it 'should translate reification with a variable right hand side and negation'  do
     @b1.must_not_be.equal_to(@b2, :reify => @b3)
     @b1.must_be.true
     @b2.must_be.false
@@ -228,9 +230,13 @@ describe Gecode::Constraints::Bool do
     sol.b3.value.should be_true
   end
   
-  it 'should raise error on right hand sides of the wrong type' do
+  it 'should raise error on right hand sides of incorrect type given to #==' do
     lambda{ @b1.must == 'hello' }.should raise_error(TypeError) 
   end
-  
+
+  it 'should raise error on right hand sides of incorrect type given to #imply' do
+    lambda{ @b1.must.imply 'hello' }.should raise_error(TypeError) 
+  end
+
   it_should_behave_like 'reifiable constraint'
-end
+end

data/specs/constraints/channel.rb

@@ -26,10 +26,23 @@ class BoolChannelSampleProblem < Gecode::Model
     @int = int_var(0..3)
     @bool = bool_var
     
-    branch_on wrap_enum([@int])
+    branch_on @int
   end
 end
 
+class SetChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :set
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @set = set_var([], 0..3)
+    
+    branch_on @bool_enum
+  end
+end
+
+
 describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
   before do
     @model = ChannelSampleProblem.new
@@ -73,10 +86,10 @@ describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
     lambda{ @elements.must.channel 'hello' }.should raise_error(TypeError) 
   end
   
-  it_should_behave_like 'reifiable constraint'
+  it_should_behave_like 'non-reifiable constraint'
 end
 
-describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum)' do
+describe Gecode::Constraints::SetEnum::Channel::IntChannelConstraint, ' (channel with set as right hand side)' do
   before do
     @model = ChannelSampleProblem.new
     @positions = @model.positions
@@ -113,7 +126,7 @@ describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum
   it_should_behave_like 'non-reifiable set constraint'
 end
 
-describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' do
+describe Gecode::Constraints::SetEnum::Channel::IntChannelConstraint, ' (channel with set as left hand side)' do
   before do
     @model = ChannelSampleProblem.new
     @positions = @model.positions
@@ -354,3 +367,88 @@ describe Gecode::Constraints::BoolEnum::Channel, ' (int variable as lhs with boo
   
   it_should_behave_like 'channel constraint between bool enum and int variable'
 end
+
+# Requires @model, @bool_enum and @set. Also requires @place_constraint which 
+# is a method that takes four variables: a boolean enum, a set variable,
+# whether or not the constraint should be negated and a hash of options, and 
+# places the channel constraint on them.
+describe 'channel constraint between set variable and bool enum', :shared => true do
+  before do
+    @invoke_options = lambda do |hash| 
+      @place_constraint.call(@bools, @set, false, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::BoolVarArray),
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  end
+  
+  it 'should channel the bool enum with the set variable' do
+    @set.must_be.superset_of [0, 2]
+    @place_constraint.call(@bools, @set, false, {})
+    @model.solve!.should_not be_nil
+    set_values = @set.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == set_values.include?(index)
+    end
+  end
+  
+  it 'should not allow negation' do
+    lambda do
+      @place_constraint.call(@bools, @set, true, {})
+    end.should raise_error(Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Channel, ' (set variable as lhs with bool enum)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @place_constraint = lambda do |bools, set, negate, options|
+      unless negate
+        set.must.channel(bools, options)
+      else
+        set.must_not.channel(bools, options)
+      end
+    end
+  end
+
+  it 'should raise error if a boolean enum is not given as right hand side' do
+    lambda do
+      @set.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between set variable and bool enum'
+end
+
+describe Gecode::Constraints::Set::Channel, ' (bool enum as lhs with set variable)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @place_constraint = lambda do |bools, set, negate, options|
+      unless negate
+        bools.must.channel(set, options)
+      else
+        bools.must_not.channel(set, options)
+      end
+    end
+  end
+
+  it 'should raise error if an integer variable is not given as right hand side' do
+    lambda do
+      @bools.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between set variable and bool enum'
+end

data/specs/constraints/extensional.rb

@@ -44,7 +44,7 @@ describe 'tuple constraint', :shared => true do
   it_should_behave_like 'non-reifiable constraint'
 end
 
-describe Gecode::Constraints::IntEnum::Extensional do
+describe Gecode::Constraints::IntEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[1,7], [5,1]]
@@ -77,7 +77,7 @@ describe Gecode::Constraints::IntEnum::Extensional do
   it_should_behave_like 'tuple constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional do
+describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[true, false, true], [false, false, true]]
@@ -109,3 +109,186 @@ describe Gecode::Constraints::BoolEnum::Extensional do
   
   it_should_behave_like 'tuple constraint'
 end
+
+# Assumes that @variables, @expected_array, @value1, @value2 (must not
+# equal @value1) and @regexp are defined. 
+describe 'regular expression constraint', :shared => true do
+  before do
+    @invoke_options = lambda do |hash| 
+      @variables.must.match(@regexp, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        @expected_array, 
+        an_instance_of(Gecode::Raw::REG), strength, kind)
+    end
+  end
+
+  it 'should handle values grouped in a single array' do
+    @variables.must.match [@value1, @value2, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+
+  it 'should allow nested groups of values' do
+    @variables.must.match [@value1, [@value2, [@value1]]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+  
+  it 'should handle the repeat operation' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle repeat operations that do not encase constant values in arrays' do
+    @variables.must.match [@value1, @model.repeat(@value2, 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations' do
+    @variables.must.match [[@model.repeat(@model.repeat([@value2], 1, 3), 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations (2)' do
+    @variables.must.match [[@model.repeat([@model.repeat(@value2, 1, 3)], 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with the last argument omitted as only giving a lower bound' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound' do
+    @variables.must.match [@model.repeat(@value2), @value1, @value1, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value1, @value1]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound (2)' do
+    @variables.must.match [@model.repeat(@value2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should translate at_most_once(reg) to repeat(reg, 0, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 0, 1)
+    @model.at_most_once [@value1]
+  end
+
+  it 'should translate at_least_once(reg) to repeat(reg, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 1)
+    @model.at_least_once [@value1]
+  end
+
+  it 'should raise error if the right hand side is not an enumeration' do
+    lambda do 
+      @variables.must.match Object.new
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the right hand side does not a regexp of the right type' do
+    lambda do 
+      @variables.must.match [@value1, 'foo'] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the right hand side contains a nested element of an incorrect type' do
+    lambda do 
+      @variables.must.match [@value1, [@value2, 'foo']] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (2)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, [0], 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (3)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, 0, [1])
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the repeat operation is given arguments of incorrect type' do
+    lambda do 
+      @variables.must.match @model.repeat('foo', 0, 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should not allow negation' do
+    lambda do 
+      @variables.must_not.match @regexp
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+describe Gecode::Constraints::IntEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @digits = @model.int_var_array(3, 0..9)
+    @model.branch_on @digits
+    @expected_array = an_instance_of Gecode::Raw::IntVarArray
+    @value1 = 3
+    @value2 = 5
+    @regexp = [1, @model.any(3, 4), @model.at_most_once(5)]
+  end
+
+  it 'should handle the any operation' do
+    @digits.must.match [1, @model.any(1, 2, 3), 3]
+    @model.solve!.should_not be_nil
+    values = @digits.values
+    values.size.should == 3 
+    values.should == values.sort
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @digits.must.match [1, @model.any(@model.at_least_once(2), [3, 5])]
+    @digits[2].must < 4
+    @model.solve!.should_not be_nil
+    @digits.values.should == [1,2,2]
+  end
+
+  it_should_behave_like 'regular expression constraint'
+end
+
+describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @bools = @model.bool_var_array(3)
+    @model.branch_on @bools
+    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
+    @value1 = true
+    @value2 = false
+    @regexp = [true, @model.any(true, false), @model.at_most_once(true)]
+  end
+
+  it 'should handle the any operation' do
+    @bools.must.match [@model.repeat(@model.any(true, false))]
+    @bools[0].must_be.true
+    @bools[1].must_be.false
+    @model.solve!.should_not be_nil
+    @bools[0].value.should be_true
+    @bools[1].value.should be_false
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @bools.must.match [@model.any(@model.at_least_once(true), [false])]
+    @model.solve!.should_not be_nil
+    @bools.values.should == [true, true, true]
+  end
+
+  it_should_behave_like 'regular expression constraint'
+end