gecoder 0.5.0 → 0.6.0

data/specs/constraints/bool_enum.rb

@@ -45,25 +45,25 @@ describe 'bool enum constraint', :shared => true do
   it 'should handle being constrained to be equal to a variable' do
     @stub.must_be == @b1
     @model.solve!
-    @compute_result.call.should == @b1.true?
+    @compute_result.call.should == @b1.value
   end
   
   it 'should handle being constrained to not be equal to a variable' do
     @stub.must_not_be == @b1
     @model.solve!
-    @compute_result.call.should_not == @b1.true?
+    @compute_result.call.should_not == @b1.value
   end
   
   it 'should handle being constrained to be equal to be a nested expression' do
     @stub.must_be == (@b1 | @b2) & @b1
     @model.solve!
-    @compute_result.call.should == (@b1.true? | @b2.true?) & @b1.true?
+    @compute_result.call.should == (@b1.value | @b2.value) & @b1.value
   end
   
   it 'should handle being constrained to not be equal to be a nested expression' do
     @stub.must_not_be == (@b1 | @b2) & @b1
     @model.solve!
-    @compute_result.call.should_not == (@b1.true? | @b2.true?) & @b1.true?
+    @compute_result.call.should_not == (@b1.value | @b2.value) & @b1.value
   end
 end
 
@@ -80,18 +80,22 @@ describe Gecode::Constraints::BoolEnum, ' (conjunction)' do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:bool_and).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::BoolVarArray), 
-        an_instance_of(Gecode::Raw::BoolVar), strength)
-      unless reif_var.nil?
-        Gecode::Raw.should_receive(:bool_eqv).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_and).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+        end
       end
     end
     
     # For bool enum spec.
     @stub = @bools.conjunction
-    @compute_result = lambda{ @bools.all?{ |b| b.true? } }
+    @compute_result = lambda{ @bools.all?{ |b| b.value } }
   end
   
   it_should_behave_like 'bool enum constraint'
@@ -111,18 +115,22 @@ describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:bool_or).once.with(@model.active_space, 
-        an_instance_of(Gecode::Raw::BoolVarArray), 
-        an_instance_of(Gecode::Raw::BoolVar), strength)
-      unless reif_var.nil?
-        Gecode::Raw.should_receive(:bool_eqv).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_or).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+        end
       end
     end
     
     # For bool enum spec.
     @stub = @bools.disjunction
-    @compute_result = lambda{ @bools.any?{ |b| b.true? } }
+    @compute_result = lambda{ @bools.any?{ |b| b.value } }
   end
   
   it_should_behave_like 'bool enum constraint'

data/specs/constraints/boolean.rb

@@ -26,12 +26,16 @@ describe Gecode::Constraints::Bool do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:bool_or).once.with(@model.active_space, 
-        @b1.bind, @b2.bind, an_instance_of(Gecode::Raw::BoolVar), 
-        Gecode::Raw::ICL_DEF)
-      unless reif_var.nil?
-        Gecode::Raw.should_receive(:bool_eqv).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_or).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          @b1.bind, @b2.bind, an_instance_of(Gecode::Raw::BoolVar), 
+          Gecode::Raw::ICL_DEF)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+        end
       end
     end
   end
@@ -40,148 +44,148 @@ describe Gecode::Constraints::Bool do
     @b1.must_be.true
     b1 = @model.solve!.b1
     b1.should be_assigned
-    b1.true?.should be_true
+    b1.value.should be_true
   end
   
   it 'should handle single variables constrainted to be false' do
     @b1.must_be.false
     b1 = @model.solve!.b1
     b1.should be_assigned
-    b1.true?.should_not be_true
+    b1.value.should_not be_true
   end
   
   it 'should handle single variables constrainted not to be false' do
     @b1.must_not_be.false
     b1 = @model.solve!.b1
     b1.should be_assigned
-    b1.true?.should be_true
+    b1.value.should be_true
   end
   
   it 'should handle single variables constrainted not to be true' do
     @b1.must_not_be.true
     b1 = @model.solve!.b1
     b1.should be_assigned
-    b1.true?.should_not be_true
+    b1.value.should_not be_true
   end
 
   it 'should handle disjunction' do
     @b1.must_be.false
     (@b1 | @b2).must_be.true
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should be_true
+    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
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should_not be_true
+    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!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
   end
 
   it 'should handle negated conjunction' do
     @b1.must_be.true
     (@b1 & @b2).must_not_be.true
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
   end
 
   it 'should handle exclusive or' do
     @b1.must_be.false
     (@b1 ^ @b2).must_be.true
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should be_true
+    sol.b1.value.should_not be_true
+    sol.b2.value.should be_true
   end
 
   it 'should handle negated exclusive or' do
     @b1.must_be.true
     (@b1 ^ @b2).must_not_be.true
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
   end
   
   it 'should handle implication' do
     @b2.must_be.false
     (@b1.implies @b2).must_be.true
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should_not be_true
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
   end
   
   it 'should handle negated implication' do
     @b1.must_be.true
     ((@b1 | @b2).implies @b2).must_not_be.true
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
   end
   
   it 'should handle imply after must' do
     @b2.must_be.false
     @b1.must.imply @b2
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should_not be_true
+    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
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
   end
 
   it 'should handle single variables as right hand side' do
     @b1.must == @b2
     @b2.must_be.false
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b2.true?.should_not be_true
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
   end
   
   it 'should handle single variables with negation as right hand side' do
     @b1.must_not == @b2
     @b2.must_be.false
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
+    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
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should be_true
+    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
     sol = @model.solve!
-    sol.b1.true?.should_not be_true
-    sol.b3.true?.should be_true
+    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
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should be_true
-    sol.b3.true?.should be_true
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+    sol.b3.value.should be_true
   end
   
   it 'should handle nested expressions containing exclusive or' do
@@ -189,9 +193,9 @@ describe Gecode::Constraints::Bool do
     @b1.must_be.true
     @b2.must_be.false
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
-    sol.b3.true?.should_not be_true
+    sol.b1.value.should be_true
+    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
@@ -199,9 +203,9 @@ describe Gecode::Constraints::Bool do
     @b1.must_be.true
     @b3.must_be.true
     sol = @model.solve!
-    sol.b1.true?.should be_true
-    sol.b2.true?.should_not be_true
-    sol.b3.true?.should be_true
+    sol.b1.value.should be_true
+    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
@@ -209,7 +213,7 @@ describe Gecode::Constraints::Bool do
     @b1.must_be.true
     @b2.must_be.false
     sol = @model.solve!
-    sol.b3.true?.should_not be_true
+    sol.b3.value.should_not be_true
   end
   
   it 'should translate reification with a variable right hand side and negation' do
@@ -217,7 +221,7 @@ describe Gecode::Constraints::Bool do
     @b1.must_be.true
     @b2.must_be.false
     sol = @model.solve!
-    sol.b3.true?.should be_true
+    sol.b3.value.should be_true
   end
   
   

data/specs/constraints/cardinality.rb

@@ -18,8 +18,11 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
       @model.solve!
     end
     @expect = lambda do |rhs|
-      Gecode::Raw.should_receive(:cardinality).once.with(@model.active_space, 
-        @set.bind, rhs.first, rhs.last)
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:cardinality).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          @set.bind, rhs.first, rhs.last)
+      end
     end
   end
   
@@ -36,7 +39,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
   it 'should constrain the cardinality of a set' do
     @set.size.must_be.in @range
     @model.solve!
-    @range.should include(@set.val_size)
+    @range.should include(@set.value.size)
   end
   
   it 'should raise error if the right hand side is not a range' do
@@ -44,10 +47,12 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
   end
   
   it 'should not shadow the integer variable domain constrain' do
-    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:dom).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), an_instance_of(Gecode::Raw::IntSet), 
-      Gecode::Raw::ICL_DEF)
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
     @set.size.must_not_be.in [1,3]
+    @model.solve!
   end
   
   it_should_behave_like 'non-reifiable set constraint'
@@ -61,35 +66,37 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
     @model.branch_on @model.wrap_enum([@set])
     @model.branch_on @model.wrap_enum([@var])
     
-    @invoke_options = lambda do |hash| 
-      @set.size.must_be.equal_to(@var, hash) 
-    end
-    
     @invoke = lambda do |rhs| 
       @set.size.must == rhs 
       @model.solve!
     end
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
-      rhs = rhs.bind if rhs.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            rhs.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:cardinality).once.with(
-            @model.active_space, @set.bind, rhs)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:cardinality).once.with( 
+              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:cardinality).once.with(
+              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
         else
           Gecode::Raw.should_receive(:cardinality).once.with(
-            @model.active_space, @set.bind, an_instance_of(Gecode::Raw::IntVar))
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
             strength)
         end
-      else
-        Gecode::Raw.should_receive(:cardinality).once.with(@model.active_space, 
-          @set.bind, an_instance_of(Gecode::Raw::IntVar))
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
-          strength)
       end
     end
     
@@ -119,7 +126,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
   it 'should constrain the cardinality of a set' do
     @set.size.must == @var
     @model.solve!
-    @set.val_size.should == @var.val
+    @set.value.size.should == @var.value
   end
   
   it_should_behave_like 'constraint with options'

data/specs/constraints/channel.rb

@@ -4,17 +4,19 @@ require File.dirname(__FILE__) + '/constraint_helper'
 class ChannelSampleProblem < Gecode::Model
   attr :elements
   attr :positions
+  attr :sets
   
   def initialize
     @elements = int_var_array(4, 0..3)
     @elements.must_be.distinct
     @positions = int_var_array(4, 0..3)
     @positions.must_be.distinct
-    branch_on @elements
+    @sets = set_var_array(4, [], 0..3)
+    branch_on @positions
   end
 end
 
-describe Gecode::Constraints::IntEnum::Channel do
+describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
   before do
     @model = ChannelSampleProblem.new
     @positions = @model.positions
@@ -24,14 +26,16 @@ describe Gecode::Constraints::IntEnum::Channel do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:channel).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVarArray), 
         an_instance_of(Gecode::Raw::IntVarArray), strength)
     end
   end
 
   it 'should translate into a channel constraint' do
-    Gecode::Raw.should_receive(:channel).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:channel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       anything, anything, Gecode::Raw::ICL_DEF)
     @invoke_options.call({})
   end
@@ -39,8 +43,8 @@ describe Gecode::Constraints::IntEnum::Channel do
   it 'should constrain variables to be channelled' do
     @elements.must.channel @positions
     @model.solve!
-    elements = @model.elements.map{ |e| e.val }
-    positions = @model.elements.map{ |p| p.val }
+    elements = @model.elements.values
+    positions = @model.elements.values
     elements.each_with_index do |element, i|
       element.should equal(positions.index(i))
     end
@@ -51,5 +55,72 @@ describe Gecode::Constraints::IntEnum::Channel do
       Gecode::MissingConstraintError) 
   end
   
+  it 'should raise error for unsupported right hand sides' do
+    lambda{ @elements.must.channel 'hello' }.should raise_error(TypeError) 
+  end
+  
   it_should_behave_like 'constraint with strength option'
 end
+
+describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum)' do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @sets = @model.sets
+  end
+
+  it 'should translate into a channel constraint' do
+    Gecode::Raw.should_receive(:channel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::SetVarArray))
+    @positions.must.channel @sets
+    @model.solve!
+  end
+  
+  it 'should constrain variables to be channelled' do
+    @positions.must.channel @sets
+    @model.solve!
+    sets = @model.sets
+    positions = @model.positions.values
+    positions.each_with_index do |position, i|
+      sets[position].value.should include(i)
+    end
+  end
+end
+
+describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @sets = @model.sets
+    
+    @invoke_options = lambda do |hash| 
+      @sets.must.channel @positions, hash
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::SetVarArray))
+    end
+  end
+
+  it 'should translate into a channel constraint' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @sets.must.channel @positions
+    @model.solve!
+  end
+
+  it 'should not allow negation' do
+    lambda{ @sets.must_not.channel @positions }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it 'should raise error for unsupported right hand sides' do
+    lambda{ @sets.must.channel 'hello' }.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end