gecoder 0.5.0 → 0.6.0

data/specs/constraints/distinct.rb

@@ -3,9 +3,12 @@ require File.dirname(__FILE__) + '/constraint_helper'
 
 class DistinctSampleProblem < Gecode::Model
   attr :vars
+  attr :sets
   
   def initialize
     @vars = int_var_array(2, 1)
+    @sets = set_var_array(2, [], 0..2)
+    branch_on wrap_enum(@sets)
   end
 end
 
@@ -17,13 +20,15 @@ describe Gecode::Constraints::IntEnum::Distinct do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:distinct).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVarArray), strength)
     end
   end
 
   it 'should translate into a distinct constraint' do
-    Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       anything, Gecode::Raw::ICL_DEF)
     @invoke_options.call({})
   end
@@ -53,10 +58,12 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
     end
     @expect_options = lambda do |strength, reif_var|
       if reif_var.nil?
-        Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
           anything, an_instance_of(Gecode::Raw::IntVarArray), strength)
       else
-        Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
           anything, an_instance_of(Gecode::Raw::IntVarArray), strength,
           an_instance_of(Gecode::Raw::BoolVar))
       end
@@ -64,7 +71,8 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
   end
 
   it 'should translate into a distinct constraint with offsets' do
-    Gecode::Raw.should_receive(:distinct).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       anything, anything, Gecode::Raw::ICL_DEF)
     @invoke_options.call({})
   end
@@ -72,8 +80,8 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
   it 'should consider offsets when making variables distinct' do
     @model.vars.with_offsets(-1,0).must_be.distinct
     x,y = @model.solve!.vars
-    x.val.should equal(1)
-    y.val.should equal(1)
+    x.value.should equal(1)
+    y.value.should equal(1)
   end
   
   # This tests two distinct in conjunction. It's here because of a bug found.
@@ -86,8 +94,8 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
   it 'should accept an array as offsets' do
     @model.vars.with_offsets([-1,0]).must_be.distinct
     x,y = @model.solve!.vars
-    x.val.should equal(1)
-    y.val.should equal(1)
+    x.value.should equal(1)
+    y.value.should equal(1)
   end
   
   it 'should not allow negation' do
@@ -96,4 +104,115 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
   end
   
   it_should_behave_like 'constraint with strength option'
+end
+
+describe Gecode::Constraints::SetEnum::Distinct do
+  before do
+    @model = DistinctSampleProblem.new
+    @sets = @model.sets
+    @size = 1
+    
+    @invoke_options = lambda do |hash| 
+      @sets.must_be.distinct(hash.update(:size => @size))
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:distinct).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::SetVarArray), @size)
+    end
+  end
+
+  it 'should translate into a distinct constraint' do
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::SetVarArray), @size)
+    @sets.must_be.distinct(:size => @size)
+    @model.solve!
+  end
+
+  it 'should constrain sets to be distinct' do
+    @sets.must_be.distinct(:size => @size)
+    @sets[0].must_be.superset_of 0
+    solution = @model.solve!
+    solution.should_not be_nil
+    set1, set2 = solution.sets
+    set1.value.size.should == @size
+    set2.value.size.should == @size
+    set1.value.should_not == set2.value
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @sets.must_not_be.distinct(:size => @size) }.should raise_error(
+      Gecode::MissingConstraintError)
+  end
+  
+  it 'should not allow options other than :size' do
+    lambda do
+      @sets.must_be.distinct(:size => @size, :foo => 17)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if :size is not specified' do
+    lambda{ @sets.must_be.distinct }.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Distinct, ' (at most one)' do
+  before do
+    @model = DistinctSampleProblem.new
+    @sets = @model.sets
+    @size = 2
+    
+    @invoke_options = lambda do |hash| 
+      @sets.must.at_most_share_one_element hash.update(:size => @size)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:atmostOne).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::SetVarArray), @size)
+    end
+  end
+
+  it 'should translate into a atmostOne constraint' do
+    Gecode::Raw.should_receive(:atmostOne).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::SetVarArray), @size)
+    @sets.must.at_most_share_one_element(:size => @size)
+    @model.solve!
+  end
+
+  it 'should constrain sets to have at most one element in common' do
+    @sets.must.at_most_share_one_element(:size => @size)
+    @sets[0].must_not_be.superset_of 0
+    solution = @model.solve!
+    solution.should_not be_nil
+    set1, set2 = solution.sets
+    set1.value.size.should == @size
+    set2.value.size.should == @size
+    (set1.value.to_a & set2.value.to_a).size.should <= 1
+  end
+
+  it 'should not allow negation' do
+    lambda do
+      @sets.must_not.at_most_share_one_element(:size => @size) 
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+  
+  it 'should not allow options other than :size' do
+    lambda do
+      @sets.must.at_most_share_one_element(:size => @size, :foo => 17) 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if :size is not specified' do
+    lambda do
+      @sets.must.at_most_share_one_element 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
 end

data/specs/constraints/element.rb

@@ -27,28 +27,35 @@ describe Gecode::Constraints::IntEnum::Element do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |element, relation, target, strength, reif_var, negated|
-      target = target.bind if target.respond_to? :bind
-      element = element.bind if element.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            target.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            element, target, strength)
+      @model.allow_space_access do
+        target = target.bind if target.respond_to? :bind
+        element = element.bind if element.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              target.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:element).once.with( 
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              element, target, strength)
+          else
+            Gecode::Raw.should_receive(:element).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              element, an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, target, strength)
+          end
         else
-          Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+          Gecode::Raw.should_receive(:element).once.with(
+            an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
             element, an_instance_of(Gecode::Raw::IntVar), strength)
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, target, strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, target, 
+            an_instance_of(Gecode::Raw::BoolVar), strength)
         end
-      else
-        Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          element, an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, target, 
-          an_instance_of(Gecode::Raw::BoolVar), strength)
       end
     end
 
@@ -83,7 +90,7 @@ describe Gecode::Constraints::IntEnum::Element do
 
   it 'should handle fixnum enums as enumeration' do
     @fixnum_prices[@store].must == @fixnum_prices[2]
-    @model.solve!.store.val.should equal(2)
+    @model.solve!.store.value.should equal(2)
   end
   
   it 'should translate reification when using equality' do

data/specs/constraints/equality.rb

@@ -10,7 +10,8 @@ describe Gecode::Constraints::IntEnum::Equality do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:eq).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:eq).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         anything, strength)
     end
   end

data/specs/constraints/int_domain.rb

@@ -15,28 +15,35 @@ describe Gecode::Constraints::Int::Domain do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-          @x.bind, an_instance_of(Gecode::Raw::IntSet), strength)
-      else
-        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-          @x.bind, an_instance_of(Gecode::Raw::IntSet), 
-          an_instance_of(Gecode::Raw::BoolVar), strength)
+      @model.allow_space_access do
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @x.bind, an_instance_of(Gecode::Raw::IntSet), strength)
+        else
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @x.bind, an_instance_of(Gecode::Raw::IntSet), 
+            an_instance_of(Gecode::Raw::BoolVar), strength)
+        end
       end
     end
   end
   
   it 'should translate domain constraints with range domains' do
-    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-      @x.bind, @range_domain.first, @range_domain.last, Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:dom).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), @range_domain.first, 
+      @range_domain.last, Gecode::Raw::ICL_DEF)
     @x.must_be.in @range_domain
     @model.solve!
   end
 
   it 'should translate domain constraints with three dot range domains' do
-    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-      @x.bind, @three_dot_range_domain.first, @three_dot_range_domain.last, 
-      Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:dom).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), @three_dot_range_domain.first, 
+      @three_dot_range_domain.last, Gecode::Raw::ICL_DEF)
     @x.must_be.in @three_dot_range_domain
     @model.solve!
   end

data/specs/constraints/int_relation.rb

@@ -15,11 +15,13 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
     end
     @expect_options = lambda do |strength, reif_var|
       if reif_var.nil?
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
           anything, Gecode::Raw::IRT_GR, anything, 
           strength)
       else
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
           an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, anything, 
           an_instance_of(Gecode::Raw::BoolVar), strength)
       end
@@ -28,7 +30,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
   
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:rel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVar), type, @int, Gecode::Raw::ICL_DEF)
       @x.must.send(relation, @int)
       @model.solve!
@@ -37,7 +40,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
 
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with constant to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:rel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVar), type, @int, Gecode::Raw::ICL_DEF)
       @x.must_not.send(relation, @int)
       @model.solve!
@@ -46,7 +50,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
 
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with variables to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:rel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVar), type, 
         an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
       @x.must.send(relation, @y)
@@ -56,7 +61,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
 
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with variable to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:rel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         an_instance_of(Gecode::Raw::IntVar), type, 
         an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
       @x.must_not.send(relation, @y)

data/specs/constraints/linear.rb

@@ -37,51 +37,51 @@ describe Gecode::Constraints::Int::Linear do
   it 'should handle addition with a variable' do
     (@x + @y).must == 0
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
+    x = sol.x.value
+    y = sol.y.value
     (x + y).should be_zero
   end
   
   it 'should handle addition with multiple variables' do
     (@x + @y + @z).must == 0
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     (x + y + z).should be_zero
   end
   
   it 'should handle subtraction with a variable' do
     (@x - @y).must == 0
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
+    x = sol.x.value
+    y = sol.y.value
     (x - y).should be_zero
   end
   
   it 'should handle non-zero constants as right hand side' do
     (@x + @y).must == 1
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
+    x = sol.x.value
+    y = sol.y.value
     (x + y).should equal(1)
   end
   
   it 'should handle variables as right hand side' do
     (@x + @y).must == @z
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     (x + y).should equal(z)
   end
   
   it 'should handle linear expressions as right hand side' do
     (@x + @y).must == @z + @y
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     (x + y).should equal(z + y)
   end
   
@@ -92,49 +92,49 @@ describe Gecode::Constraints::Int::Linear do
   it 'should handle coefficients other than 1' do
     (@x * 2 + @y).must == 0
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
+    x = sol.x.value
+    y = sol.y.value
     (2*x + y).should equal(0)
   end
   
   it 'should handle addition with constants' do
     (@y + 2).must == 1
     sol = @model.solve!
-    y = sol.y.val
+    y = sol.y.value
     (y + 2).should equal(1)
   end
   
   it 'should handle subtraction with a constant' do
     (@x - 2).must == 0
     sol = @model.solve!
-    x = sol.x.val
+    x = sol.x.value
     (x - 2).should be_zero
   end
   
   it 'should a single variable as left hande side' do
     @x.must == @y + @z
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     x.should equal(y + z)
   end
   
   it 'should handle parenthesis' do
     (@x - (@y + @z)).must == 1
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     (x - (y + z)).should equal(1)
   end
   
   it 'should handle multiplication of parenthesis' do
     (((@x + @y*10)*10 + @z)*10).must == 0
     sol = @model.solve!
-    x = sol.x.val
-    y = sol.y.val
-    z = sol.z.val
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
     (((x + y*10)*10 + z)*10).should equal(0)
   end
   
@@ -145,7 +145,7 @@ describe Gecode::Constraints::Int::Linear do
       (@x + @y).must.send(relation, 1)
       sol = @model.solve!
       sol.should_not be_nil
-      (sol.x.val + sol.y.val).should.send(relation, 1)
+      (sol.x.value + sol.y.value).should.send(relation, 1)
     end
   end
   
@@ -154,7 +154,7 @@ describe Gecode::Constraints::Int::Linear do
       (@x + @y).must_not.send(relation, 1)
       sol = @model.solve!
       sol.should_not be_nil
-      (sol.x.val + sol.y.val).should_not.send(relation, 1)
+      (sol.x.value + sol.y.value).should_not.send(relation, 1)
     end
   end