gecoder-with-gecode 0.7.1-mswin32

data/specs/constraints/reification_sugar.rb

@@ -0,0 +1,96 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class ReifSugarSampleProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize
+    @x = int_var(0..1)
+    @y = int_var(1..2)
+    @z = int_var(3..4)
+    branch_on wrap_enum([@x, @y, @z])
+  end
+end
+
+describe Gecode::Constraints::ReifiableConstraint do
+  before do
+    @model = ReifSugarSampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+  end
+
+  it 'should fail disjunctions if neither side can be satisfied' do
+    (@x.must == 3) | (@y.must == 3)
+    @model.solve!.should be_nil
+  end
+  
+  it 'should translate disjunctions' do
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 3, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    (@x.must > 0) | (@y.must == 3)
+    sol = @model.solve!
+  end
+  
+  it 'should solve disjunctions' do
+    (@x.must > 0) | (@y.must == 3)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([1])
+  end
+  
+  it 'should fail conjunctions if one side can\'t be satisfied' do
+    (@x.must > 3) & (@y.must == 3)
+    @model.solve!.should be_nil
+  end
+  
+  it 'should translate conjunctions' do
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 2, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    (@x.must > 0) & (@y.must == 2)
+    sol = @model.solve!
+  end
+  
+  it 'should solve conjunctions' do
+    (@x.must > 0) & (@y.must == 2)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([1])
+    sol.y.should have_domain([2])
+  end
+
+  it 'should handle the same variable being used multiple times' do
+    (@z.must == 4) | (@z.must == 4)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.z.should have_domain([4])
+  end
+  
+  it 'should handle nested operations' do
+    ((@x.must > 3) & (@y.must == 2)) | (@z.must == 4) | (
+      (@x.must == 0) & (@z.must == 4))
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([0])
+    sol.z.should have_domain([4])
+  end
+  
+  it 'should handle negations' do
+    (@z.must_not == 4) & (@z.must == 4)
+    sol = @model.solve!
+    sol.should be_nil
+  end
+end

data/specs/constraints/selection.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class SelectionSampleProblem < Gecode::Model
+  attr :sets
+  attr :set
+  attr :target
+  attr :index
+  
+  def initialize
+    @sets = set_var_array(3, [], 0..20)
+    @set = set_var([], 0...3)
+    @target = set_var([], 0..20)
+    @index = int_var(0...3)
+    branch_on wrap_enum([@index])
+    branch_on @sets
+  end
+end
+
+# Requires everything that composite behaviour spec requires in addition to
+# @stub and @expect_constrain_equal .
+describe 'selection constraint', :shared => true do
+  before do
+    @expect = lambda do |index, relation, target, reif_var, negated|
+      @model.allow_space_access do
+        if target.respond_to? :bind
+          expected_target = [an_instance_of(Gecode::Raw::SetVar)]
+          relation_constraint = :rel
+        else
+          expected_target = expect_constant_set(target)
+          relation_constraint = :dom
+        end
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              !target.kind_of? Enumerable
+            @expect_constrain_equal.call
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+            Gecode::Raw.should_receive(:dom).exactly(0).times
+          else
+            @expect_constrain_equal.call
+            if relation_constraint == :dom
+              # We can't seem to get any more specific than this with mocks. 
+              Gecode::Raw.should_receive(relation_constraint).at_most(:twice)
+            else
+              Gecode::Raw.should_receive(relation_constraint).once.with(
+                an_instance_of(Gecode::Raw::Space), 
+                an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
+            end
+          end
+        else
+          @expect_constrain_equal.call
+          if relation_constraint == :dom
+            Gecode::Raw.should_receive(relation_constraint).at_least(:twice)
+          else
+            expected_target << an_instance_of(Gecode::Raw::BoolVar)
+            Gecode::Raw.should_receive(relation_constraint).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
+          end
+        end
+      end
+    end
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @stub.must_not.send(relation, target)
+      else
+        @stub.must.send(relation, target)
+      end
+      @model.solve!
+    end
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(@index, relation, target, nil, negated)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @stub.must_be.subset_of(@target, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(17, Gecode::Raw::SRT_SUB, @target, reif_var, false)
+    end
+  end
+  
+  it 'should not disturb normal array access' do
+    @sets[0].should be_kind_of(Gecode::FreeSetVar)
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+  it_should_behave_like 'composite set constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (select)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @target = @set = @model.target
+    @index = @model.index
+    @model.branch_on @model.wrap_enum([@set])
+    @stub = @sets[@index]
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectSet).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  end
+  
+  it 'should constrain the specified element of an enum of sets' do
+    @sets[@index].must_be.superset_of([5,7,9])
+    @model.solve!
+    @sets[@index.value].value.should include(5,7,9)
+  end
+  
+  it_should_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (union)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @target = @model.target
+    @model.branch_on @model.wrap_enum([@target, @set])
+    @stub = @sets[@set].union
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectUnion).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  end
+  
+  it 'should constrain the selected union of an enum of sets' do
+    @sets[@set].union.must_be.subset_of([5,7,9])
+    @sets[@set].union.must_be.superset_of([5])
+    @model.solve!
+    union = @set.value.inject([]) do |union, i|
+      union += @sets[i].value.to_a
+    end.uniq
+    union.should include(5)
+    (union - [5,7,9]).should be_empty
+  end
+  
+  it_should_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (intersection)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @target = @model.target
+    @model.branch_on @model.wrap_enum([@target, @set])
+    @stub = @sets[@set].intersection
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectInter).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  end
+  
+  it 'should constrain the selected intersection of an enum of sets' do
+    @sets[@set].intersection.must_be.subset_of([5,7,9])
+    @sets[@set].intersection.must_be.superset_of([5])
+    @model.solve!
+    intersection = @set.value.inject(nil) do |intersection, i|
+      elements = @sets[i].value.to_a
+      next elements if intersection.nil?
+      intersection &= elements
+    end.uniq
+    intersection.should include(5)
+    (intersection - [5,7,9]).should be_empty
+  end
+  
+  it_should_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (intersection with universe)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @target = @model.target
+    @model.branch_on @model.wrap_enum([@target, @set])
+    @universe = [1,2]
+    @stub = @sets[@set].intersection(:with => @universe)
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectInterIn).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar),
+        an_instance_of(Gecode::Raw::IntSet))
+    end
+  end
+  
+  it 'should constrain the selected intersection of an enum of sets in a universe' do
+    @sets[@set].intersection(:with => @universe).must_be.subset_of([2])
+    @model.solve!
+    intersection = @set.value.inject(@universe) do |intersection, i|
+      intersection &= @sets[i].value.to_a
+    end.uniq
+    intersection.should include(2)
+    (intersection - [1,2]).should be_empty
+  end
+  
+  it 'should allow the universe to be specified as a range' do
+    @sets[@set].intersection(:with => 1..2).must_be.subset_of([2])
+    @model.solve!
+    intersection = @set.value.inject(@universe) do |intersection, i|
+      intersection &= @sets[i].value.to_a
+    end.uniq
+    intersection.should include(2)
+    (intersection - [1,2]).should be_empty
+  end
+  
+  it 'should raise error if unknown options are specified' do
+    lambda do
+      @sets[@set].intersection(:does_not_exist => nil).must_be.subset_of([2])
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if the universe is of the wrong type' do
+    lambda do
+      @sets[@set].intersection(:with => 'foo').must_be.subset_of([2])
+    end.should raise_error(TypeError)
+  end
+  
+  it_should_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (disjoint)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @target = @model.target
+    @model.branch_on @model.wrap_enum([@target, @set])
+    
+    @expect = lambda do |index|
+      Gecode::Raw.should_receive(:selectDisjoint)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @sets[@set].must_be.disjoint(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@set)
+    end
+  end
+  
+  it 'should constrain the selected sets to be disjoint' do
+    @sets[0].must_be.superset_of([7,8])
+    @sets[1].must_be.superset_of([5,7,9])
+    @sets[2].must_be.superset_of([6,8,10])
+    @sets[@set].must_be.disjoint
+    @set.size.must > 1
+    @model.solve!.should_not be_nil
+    
+    @set.value.to_a.sort.should == [1,2]
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @sets[@set].must_not_be.disjoint }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end

data/specs/constraints/set_domain.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Set::Domain do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @glb = [0]
+    @lub = 0..3
+    @set = @model.set_var(@glb, @lub)
+    @range = 0..1
+    @non_range = [0, 2]
+    @singleton = 0
+    
+    @expect = lambda do |relation_type, rhs, reif_var, negated|
+      @model.allow_space_access do
+        if reif_var.nil? and !negated
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::SetVar), relation_type, 
+            *expect_constant_set(rhs))
+        else
+          params = [an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::SetVar), relation_type]
+          params << expect_constant_set(rhs)
+          params << an_instance_of(Gecode::Raw::BoolVar)
+          Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+        end
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.superset_of(@non_range, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_SUP, @non_range, reif_var, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    next if relation == :==
+  
+    it "should translate #{relation} with constant range to domain constraint" do
+      @expect.call(type, @range, nil, false)
+      @set.must.send(relation, @range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant non-range to domain constraint" do
+      @expect.call(type, @non_range, nil, false)
+      @set.must.send(relation, @non_range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant singleton to domain constraint" do
+      @expect.call(type, @singleton, nil, false)
+      @set.must.send(relation, @singleton)
+      @model.solve!
+    end
+  
+    it "should translate negated #{relation} with constant range to domain constraint" do
+      @expect.call(type, @range, nil, true)
+      @set.must_not.send(relation, @range)
+      @model.solve!
+    end
+    
+    it "should translate negated #{relation} with constant non-range to domain constraint" do
+      @expect.call(type, @non_range, nil, true)
+      @set.must_not.send(relation, @non_range)
+      @model.solve!
+    end
+    
+    it "should translate negated #{relation} with constant singleton to domain constraint" do
+      @expect.call(type, @singleton, nil, true)
+      @set.must_not.send(relation, @singleton)
+      @model.solve!
+    end
+  end
+  
+  it 'should raise error if the right hand side is not a constant set' do
+    lambda do
+      @set.must_be.superset_of('not a constant set')
+    end.should raise_error(TypeError)
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Domain, ' (equality)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = Gecode::Model.new
+    @glb = [0]
+    @lub = 0..3
+    @set = @model.set_var(@glb, @lub)
+    @range = 0..1
+    @non_range = [0, 2]
+    @singleton = 0
+    
+    @expect = lambda do |relation_type, rhs, 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::SetVar), relation_type, 
+            *expect_constant_set(rhs))
+        else
+          params = [an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::SetVar), relation_type]
+          params << expect_constant_set(rhs)
+          params << an_instance_of(Gecode::Raw::BoolVar)
+          Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+        end
+      end
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash| 
+      @set.must_be.equal_to(@non_range, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::SRT_EQ, @non_range, reif_var)
+    end
+  end
+  
+  it 'should translate equality with constant range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @range, nil)
+    @set.must == @range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant non-range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @non_range, nil)
+    @set.must == @non_range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant singleton to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_EQ, @singleton, nil)
+    @set.must == @singleton
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @range, nil)
+    @set.must_not == @range
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant non-range to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @non_range, nil)
+    @set.must_not == @non_range
+    @model.solve!
+  end
+  
+  it 'should translate negated equality with constant singleton to domain constraint' do
+    @expect.call(Gecode::Raw::SRT_NQ, @singleton, nil)
+    @set.must_not == @singleton
+    @model.solve!
+  end
+  
+  it 'should constrain the domain with equality' do
+    @set.must == @singleton
+    @model.solve!
+    @set.should be_assigned
+    @set.value.should include(@singleton)
+    @set.value.size.should == 1
+  end
+  
+  it 'should constrain the domain with inequality' do
+    @set.must_not == @singleton
+    @model.solve!.should be_nil
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end