gecoder 0.7.1 → 0.8.0

data/specs/constraints/count.rb

@@ -22,7 +22,7 @@ describe Gecode::Constraints::IntEnum::Count do
     @target = @model.target
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |element, relation, target, strength, reif_var|
+    @expect = lambda do |element, relation, target, strength, kind, reif_var|
       @model.allow_space_access do
         target = an_instance_of(Gecode::Raw::IntVar) if target.respond_to? :bind
         element = an_instance_of(Gecode::Raw::IntVar) if element.respond_to? :bind
@@ -30,17 +30,17 @@ describe Gecode::Constraints::IntEnum::Count do
           Gecode::Raw.should_receive(:count).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
-            element, relation, target, strength)
+            element, relation, target, strength, kind)
         else
           Gecode::Raw.should_receive(:count).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
             element, Gecode::Raw::IRT_EQ,
-            an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), strength, kind)
           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)
+            target, an_instance_of(Gecode::Raw::BoolVar), strength, kind)
         end
       end
     end
@@ -50,8 +50,9 @@ describe Gecode::Constraints::IntEnum::Count do
       @list.count(@element).must_be.greater_than(@target, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(@element, Gecode::Raw::IRT_GR, @target, strength, reif_var)
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      @expect.call(@element, Gecode::Raw::IRT_GR, @target, strength, 
+        kind, reif_var)
     end
   end
 
@@ -61,14 +62,16 @@ describe Gecode::Constraints::IntEnum::Count do
 
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with variable element and target" do
-      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF,
+        Gecode::Raw::PK_DEF, nil)
       @list.count(@element).must.send(relation, @target)
       @model.solve!
     end
   end
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with variable element and target" do
-      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil)
       @list.count(@element).must_not.send(relation, @target)
       @model.solve!
     end
@@ -76,14 +79,16 @@ describe Gecode::Constraints::IntEnum::Count do
   
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with variable element and constant target" do
-      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil)
       @list.count(@element).must.send(relation, 2)
       @model.solve!
     end
   end
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with variable element and constant target" do
-      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil)
       @list.count(@element).must_not.send(relation, 2)
       @model.solve!
     end
@@ -91,14 +96,14 @@ describe Gecode::Constraints::IntEnum::Count do
   
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant element and constant target" do
-      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF, nil)
       @list.count(1).must.send(relation, 2)
       @model.solve!
     end
   end
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with constant element and constant target" do
-      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF, nil)
       @list.count(1).must_not.send(relation, 2)
       @model.solve!
     end
@@ -106,14 +111,16 @@ describe Gecode::Constraints::IntEnum::Count do
 
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant element and variable target" do
-      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil)
       @list.count(1).must.send(relation, @target)
       @model.solve!
     end
   end
   Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
     it "should translate negated #{relation} with constant element and variable target" do
-      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil)
       @list.count(1).must_not.send(relation, @target)
       @model.solve!
     end
@@ -135,5 +142,5 @@ describe Gecode::Constraints::IntEnum::Count do
     @model.solve!.should be_nil
   end
   
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/distinct.rb

@@ -19,17 +19,17 @@ describe Gecode::Constraints::IntEnum::Distinct do
       @model.vars.must_be.distinct(hash)
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       Gecode::Raw.should_receive(:distinct).once.with(
         an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), strength)
+        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
     end
   end
 
   it 'should translate into a distinct constraint' do
     Gecode::Raw.should_receive(:distinct).once.with(
       an_instance_of(Gecode::Raw::Space), 
-      anything, Gecode::Raw::ICL_DEF)
+      anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
     @invoke_options.call({})
   end
 
@@ -46,7 +46,7 @@ describe Gecode::Constraints::IntEnum::Distinct do
       Gecode::MissingConstraintError) 
   end
   
-  it_should_behave_like 'constraint with strength option'
+  it_should_behave_like 'non-reifiable constraint'
 end
 
 describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
@@ -56,16 +56,16 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
       @model.vars.with_offsets(1,2).must_be.distinct(hash)
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       if reif_var.nil?
         Gecode::Raw.should_receive(:distinct).once.with(
           an_instance_of(Gecode::Raw::Space), 
-          anything, an_instance_of(Gecode::Raw::IntVarArray), strength)
+          anything, an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
       else
         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))
+          anything, an_instance_of(Gecode::Raw::IntVarArray), 
+          strength, kind, reif_var)
       end
     end
   end
@@ -73,7 +73,7 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
   it 'should translate into a distinct constraint with offsets' do
     Gecode::Raw.should_receive(:distinct).once.with(
       an_instance_of(Gecode::Raw::Space), 
-      anything, anything, Gecode::Raw::ICL_DEF)
+      anything, anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
     @invoke_options.call({})
   end
 
@@ -103,61 +103,7 @@ describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
       raise_error(Gecode::MissingConstraintError)
   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'
+  it_should_behave_like 'non-reifiable constraint'
 end
 
 describe Gecode::Constraints::SetEnum::Distinct, ' (at most one)' do

data/specs/constraints/element.rb

@@ -26,7 +26,7 @@ describe Gecode::Constraints::IntEnum::Element do
     @fixnum_prices = @model.fixnum_prices
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |element, relation, target, strength, reif_var, negated|
+    @expect = lambda do |element, relation, target, strength, kind, reif_var, negated|
       @model.allow_space_access do
         target = an_instance_of(Gecode::Raw::IntVar) if target.respond_to? :bind
         element = an_instance_of(Gecode::Raw::IntVar) if element.respond_to? :bind
@@ -36,25 +36,26 @@ describe Gecode::Constraints::IntEnum::Element do
             Gecode::Raw.should_receive(:element).once.with( 
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVarArray), 
-              element, target, strength)
+              element, target, strength, kind)
           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)
+              element, an_instance_of(Gecode::Raw::IntVar), strength, kind)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, target, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              relation, target, strength, kind)
           end
         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)
+            element, an_instance_of(Gecode::Raw::IntVar), strength, kind)
           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)
+            an_instance_of(Gecode::Raw::BoolVar), strength, kind)
         end
       end
     end
@@ -64,9 +65,9 @@ describe Gecode::Constraints::IntEnum::Element do
       @prices[@store].must_be.greater_than(@price, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(@store, Gecode::Raw::IRT_GR, @price, strength, reif_var, 
-        false)
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      @expect.call(@store, Gecode::Raw::IRT_GR, @price, strength, kind, 
+        reif_var, false)
     end
     
     # For composite spec.
@@ -79,7 +80,8 @@ describe Gecode::Constraints::IntEnum::Element do
       @model.solve!
     end
     @expect_relation = lambda do |relation, target, negated|
-      @expect.call(@store, relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+      @expect.call(@store, relation, target, Gecode::Raw::ICL_DEF, 
+        Gecode::Raw::PK_DEF, nil, negated)
     end
   end
 
@@ -96,11 +98,11 @@ describe Gecode::Constraints::IntEnum::Element do
   it 'should translate reification when using equality' do
     bool_var = @model.bool_var
     @expect.call(@store, Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, 
-      bool_var, false)
+      Gecode::Raw::PK_DEF, bool_var, false)
     @prices[@store].must_be.equal_to(@target, :reify => bool_var)
     @model.solve!
   end
   
   it_should_behave_like 'composite constraint'
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/equality.rb

@@ -9,15 +9,15 @@ describe Gecode::Constraints::IntEnum::Equality do
       @vars.must_be.equal(hash)
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       Gecode::Raw.should_receive(:eq).once.with(
         an_instance_of(Gecode::Raw::Space), 
-        anything, strength)
+        anything, strength, kind)
     end
   end
   
   it 'should translate equality constraints' do
-    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @expect_options.call({})
     @invoke_options.call({})
     @vars.must_be.equal
   end
@@ -27,5 +27,5 @@ describe Gecode::Constraints::IntEnum::Equality do
       Gecode::MissingConstraintError)
   end
   
-  it_should_behave_like 'constraint with strength option'
+  it_should_behave_like 'non-reifiable constraint'
 end

data/specs/constraints/int_domain.rb

@@ -14,19 +14,20 @@ describe Gecode::Constraints::Int::Domain do
       @x.must_be.in(@non_range_domain, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
         if reif_var.nil?
           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), strength)
+            an_instance_of(Gecode::Raw::IntSet), 
+            strength, kind)
         else
           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), 
-            an_instance_of(Gecode::Raw::BoolVar), strength)
+            reif_var, strength, kind)
         end
       end
     end
@@ -36,7 +37,7 @@ describe Gecode::Constraints::Int::Domain do
     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)
+      @range_domain.last, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
     @x.must_be.in @range_domain
     @model.solve!
   end
@@ -45,13 +46,13 @@ describe Gecode::Constraints::Int::Domain do
     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)
+      @three_dot_range_domain.last, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
     @x.must_be.in @three_dot_range_domain
     @model.solve!
   end
   
   it 'should translate domain constraints with non-range domains' do
-    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @expect_options.call({})
     @invoke_options.call({})
   end
   
@@ -65,5 +66,5 @@ describe Gecode::Constraints::Int::Domain do
     lambda{ @x.must_be.in 'hello' }.should raise_error(TypeError)
   end
   
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/int_relation.rb

@@ -13,17 +13,17 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
       @x.must_be.greater_than(3, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
+    @expect_options = option_expectation do |strength, kind, reif_var|
       if reif_var.nil?
         Gecode::Raw.should_receive(:rel).once.with(
           an_instance_of(Gecode::Raw::Space), 
           anything, Gecode::Raw::IRT_GR, anything, 
-          strength)
+          strength, kind)
       else
         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)
+          reif_var, strength, kind)
       end
     end
   end
@@ -32,7 +32,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
     it "should translate #{relation} with constant to simple relation" do
       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)
+        an_instance_of(Gecode::Raw::IntVar), 
+        type, @int, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
       @x.must.send(relation, @int)
       @model.solve!
     end
@@ -42,7 +43,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
     it "should translate negated #{relation} with constant to simple relation" do
       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)
+        an_instance_of(Gecode::Raw::IntVar), 
+        type, @int, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
       @x.must_not.send(relation, @int)
       @model.solve!
     end
@@ -53,7 +55,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
       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)
+        an_instance_of(Gecode::Raw::IntVar), 
+        Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
       @x.must.send(relation, @y)
       @model.solve!
     end
@@ -64,7 +67,8 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
       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)
+        an_instance_of(Gecode::Raw::IntVar), 
+        Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
       @x.must_not.send(relation, @y)
       @model.solve!
     end
@@ -74,5 +78,5 @@ describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
     lambda{ @x.must == 'hello' }.should raise_error(TypeError) 
   end
   
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end