gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/property_helper.rb

@@ -0,0 +1,443 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Every property should have a spec that specs the following:
+#
+# * An example where the property is used to constrain a sample problem.
+# * should_behave_like foo operand
+# * A test that the property is translated to the correct Gecode
+# constraint if deemed necessary.
+
+# Several of these shared specs requires one or more of the following instance 
+# variables to be used: 
+# [@operand]  The operand that is being tested.
+# [@model]    The model that defines the context in which the test is
+#             conducted.
+# [@property_types]  An array of symbols signaling what types of
+#                    arguments @select_property accepts. The symbols
+#                    must be one of: :int, :bool, :set, :int_enum,
+#                    :bool_enum, :set_enum, :fixnum_enum.
+# [@select_property] A proc that selects the property under test. It
+#                    should take at least one argument: the operand that
+#                    the property should be selected from.
+# [@selected_property] The resulting operand of the property. It should
+#                      be constrained to the degree that it has a
+#                      non-maximal domain.
+# [@constraint_class] The class of the constraints that are expected to be
+#                     produced when a constraint is short circuited.
+#
+
+
+# Requires @operand and @model.
+describe 'int var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_int_var' do
+    int_var = @operand.to_int_var
+    int_var.should be_kind_of(Gecode::IntVar)
+    @model.solve!
+    (int_var.min..int_var.max).should_not equal(Gecode::Model::LARGEST_INT_DOMAIN)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Int::IntConstraintReceiver)
+  end
+end
+
+# Requires @operand and @model.
+describe 'bool var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_bool_var' do
+    bool_var = @operand.to_bool_var
+    bool_var.should be_kind_of(Gecode::BoolVar)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Bool::BoolConstraintReceiver)
+  end
+end
+
+# Requires @operand and @model.
+describe 'set var operand', :shared => true do
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_set_var' do
+    set_var = @operand.to_set_var
+    set_var.should be_kind_of(Gecode::SetVar)
+    @model.solve!
+    ((set_var.lower_bound == []) && 
+     (set_var.upper_bound == Gecode::Model::LARGEST_SET_BOUND)).should_not(
+      be_true)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::Set::SetConstraintReceiver)
+  end
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces operand', :shared => true do
+  it 'should raise errors if parameters of the incorrect type are given' do
+    operands, variables = produce_general_arguments(@property_types)
+    (1...operands.size).each do |i|
+      bogus_operands = operands.clone
+      bogus_operands[i] = Object.new
+      lambda do
+        @select_property.call(*bogus_operands)
+      end.should raise_error(TypeError)
+    end
+  end
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces int operand', :shared => true do
+  it 'should produce int operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for int var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    int_var = operand.to_int_var
+    int_var.should be_kind_of(Gecode::IntVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Int::IntConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces bool operand', :shared => true do
+  it 'should produce bool operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for bool var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    bool_var = operand.to_bool_var
+    bool_var.should be_kind_of(Gecode::BoolVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Bool::BoolConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @property_types and @select_property.
+describe 'property that produces set operand', :shared => true do
+  it 'should produce set operand' do
+    operands, variables = produce_general_arguments(@property_types)
+    operand = @select_property.call(*operands)
+
+    # Test the same invariants as in the test for int var operands.
+    operand.model.should be_kind_of(Gecode::Model)
+
+    set_var = operand.to_set_var
+    set_var.should be_kind_of(Gecode::SetVar)
+
+    receiver = operand.must
+    receiver.should be_kind_of(
+      Gecode::Set::SetConstraintReceiver)
+  end
+
+  it_should_behave_like 'property that produces operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is an int operand.
+describe 'property that produces int operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    int_operand = @selected_property
+    direct_int_var = int_operand.to_int_var
+    indirect_int_op, _ = general_int_operand(@model)
+    @selected_property.must == indirect_int_op
+    @model.solve!
+
+    direct_int_var.should_not have_domain(Gecode::Model::LARGEST_INT_DOMAIN)
+    direct_int_var.should have_domain(indirect_int_op.domain)
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.int_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.int_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    @selected_property.must.equal(@model.int_var, 
+      :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when the right hand side is not a operand' do
+    @selected_property.must.equal(2).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must > @model.int_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces int operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is a bool operand.
+describe 'property that produces bool operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    bool_operand = @selected_property
+    direct_bool_var = bool_operand.to_bool_var
+    indirect_bool_var = @model.bool_var
+    @selected_property.must == indirect_bool_var
+    @model.solve!
+
+    direct_bool_var.value.should == indirect_bool_var.value
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.bool_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.bool_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    @selected_property.must.equal(@model.bool_var, 
+      :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must.imply @model.bool_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces bool operand'
+end
+
+# Requires @model, @constraint_class, @property_types and @select_property.
+# 
+# These properties should short circuit all comparison relations
+# even when negated and when fixnums are used as right hand side.
+describe 'property that produces int operand by short circuiting relations', :shared => true do
+  it 'should produce reifiable constraints when short circuited' do
+    @constraint_class.superclass.should == 
+      Gecode::ReifiableConstraint
+  end
+
+  Gecode::Util::RELATION_TYPES.keys.each do |relation|
+    it "should give the same solution regardless of whether short circuit #{relation} was used" do
+      direct_int_var = @model.int_var
+      @selected_property.to_int_var.must.method(relation).call direct_int_var
+      indirect_int_var = @model.int_var
+      @selected_property.must.method(relation).call indirect_int_var
+      @model.solve!
+
+      direct_int_var.should_not have_domain(Gecode::Model::LARGEST_INT_DOMAIN)
+      direct_int_var.should have_domain(indirect_int_var.domain)
+    end
+
+    it "should short circuit #{relation}" do
+      (@selected_property.must.method(relation).call @model.int_var).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit negated #{relation}" do
+      (@selected_property.must_not.method(relation).call @model.int_var).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} when reification is used" do
+      (@selected_property.must.method(relation).call(@model.int_var, 
+        :reify => @model.bool_var)).should(be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} even when the right hand side is a fixnum" do
+      (@selected_property.must.method(relation).call 2).should(
+        be_kind_of(@constraint_class))
+    end
+
+    it "should raise error when the #{relation} right hand side is of illegal type" do
+      lambda do
+        @selected_property.must.method(relation).call('foo')
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it_should_behave_like 'property that produces int operand'
+end
+
+# Requires @model, @constraint_class, @property_types, @select_property and
+# @selected_property.
+#
+# These properties should only short circuit equality when there is no
+# negation nor reification and the right hand side is a set operand.
+describe 'property that produces set operand by short circuiting equality', :shared => true do
+  it 'should produce constraints when short circuited' do
+    @constraint_class.superclass.should == Gecode::Constraint
+  end
+
+  it 'should give the same solution regardless of whether short circuit was used' do
+    set_operand = @selected_property
+    direct_set_var = set_operand.to_set_var
+    indirect_set_var = @model.set_var
+    @selected_property.must == indirect_set_var
+    @model.solve!
+
+    direct_set_var.should have_bounds(indirect_set_var.lower_bound, 
+      indirect_set_var.upper_bound)
+  end
+
+  it 'should short circuit equality' do
+    (@selected_property.must == @model.set_var).should(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when negation is used' do
+    (@selected_property.must_not == @model.set_var).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when reification is used' do
+    (@selected_property.must.equal(@model.set_var, 
+      :reify => @model.bool_var)).should_not(be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when the right hand side is not a operand' do
+    (@selected_property.must == [1,3,5]).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should not short circuit when equality is not used' do
+    (@selected_property.must_be.subset_of(@model.set_var)).should_not(
+      be_kind_of(@constraint_class))
+  end
+
+  it 'should raise error when the right hand side is of illegal type' do
+    lambda do
+      @selected_property.must == 'foo'
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'property that produces set operand'
+end
+
+# Requires @model, @constraint_class, @property_types and @select_property.
+# 
+# These properties should only short circuit set relations when neither
+# negation nor reification is used (both for constant sets and set
+# variables). 
+describe 'property that produces set operand by short circuiting set relations', :shared => true do
+  Gecode::Util::SET_RELATION_TYPES.keys.each do |relation|
+    it 'should produce constraints when short circuited' do
+      @constraint_class.superclass.should == Gecode::Constraint
+    end
+
+    it "should give the same solution regardless of whether short circuit #{relation} was used" do
+      if relation == :complement
+        direct_set_var, indirect_set_var = Array.new(2){ @model.set_var }
+      else
+        direct_set_var, indirect_set_var = Array.new(2) do
+          @model.set_var([], -1000..1000)
+        end
+      end
+
+      @selected_property.to_set_var.must.method(relation).call direct_set_var
+      @selected_property.must.method(relation).call indirect_set_var
+      @model.solve!
+
+      if relation == :complement
+        direct_set_var.upper_bound.min.should == 
+          indirect_set_var.upper_bound.min
+        direct_set_var.upper_bound.max.should == 
+          indirect_set_var.upper_bound.max
+        direct_set_var.lower_bound.min.should ==
+          indirect_set_var.lower_bound.min
+        direct_set_var.lower_bound.max.should == 
+          indirect_set_var.lower_bound.max
+        direct_set_var.lower_bound.size.should == 
+          indirect_set_var.lower_bound.size
+      else
+        direct_set_var.should have_bounds(indirect_set_var.lower_bound, 
+          indirect_set_var.upper_bound)
+      end
+    end
+
+    it "should short circuit #{relation}" do
+      @selected_property.must.method(relation).call(@model.set_var).should( 
+        be_kind_of(@constraint_class))
+    end
+
+    it "should not short circuit negated #{relation}" do
+      @selected_property.must_not.method(relation).call(
+        @model.set_var).should_not(be_kind_of(@constraint_class))
+    end
+    
+    it "should not short circuit reified #{relation}" do
+      @selected_property.must.method(relation).call(@model.set_var, 
+        :reify => @model.bool_var).should_not(be_kind_of(@constraint_class))
+    end
+
+    it "should short circuit #{relation} even when the right hand side is a constant set" do
+      @selected_property.must.method(relation).call([1, 2, 3]).should( 
+        be_kind_of(@constraint_class))
+    end
+
+    it "should raise error when the #{relation} right hand side is of illegal type" do
+      lambda do
+        @selected_property.must.method(relation).call('foo')
+      end.should raise_error(TypeError)
+    end
+  end
+
+  it_should_behave_like 'property that produces set operand'
+end

data/specs/constraints/reification_sugar.rb

@@ -13,7 +13,7 @@ class ReifSugarSampleProblem < Gecode::Model
   end
 end
 
-describe Gecode::Constraints::ReifiableConstraint do
+describe Gecode::ReifiableConstraint do
   before do
     @model = ReifSugarSampleProblem.new
     @x = @model.x
@@ -23,7 +23,7 @@ describe Gecode::Constraints::ReifiableConstraint do
 
   it 'should fail disjunctions if neither side can be satisfied' do
     (@x.must == 3) | (@y.must == 3)
-    @model.solve!.should be_nil
+    lambda{ @model.solve! }.should raise_error(Gecode::NoSolutionError)
   end
   
   it 'should solve disjunctions' do
@@ -35,7 +35,7 @@ describe Gecode::Constraints::ReifiableConstraint do
   
   it 'should fail conjunctions if one side can\'t be satisfied' do
     (@x.must > 3) & (@y.must == 3)
-    @model.solve!.should be_nil
+    lambda{ @model.solve! }.should raise_error(Gecode::NoSolutionError)
   end
 
   it 'should solve conjunctions' do
@@ -64,7 +64,6 @@ describe Gecode::Constraints::ReifiableConstraint do
   
   it 'should handle negations' do
     (@z.must_not == 4) & (@z.must == 4)
-    sol = @model.solve!
-    sol.should be_nil
+    lambda{ @model.solve! }.should raise_error(Gecode::NoSolutionError)
   end
 end

data/specs/constraints/selected_set/select.rb

@@ -0,0 +1,56 @@
+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
+
+describe Gecode::SetEnum::Select, ' (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])
+    
+    @types = [:selected_set]
+    @invoke = lambda do |receiver, hash| 
+      receiver.disjoint(hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      set_enum, set = var
+      Gecode::Raw.should_receive(:selectDisjoint).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        set_enum, 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_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+

data/specs/constraints/selected_set/select_properties.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/../property_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
+
+describe Gecode::SelectedSet::Select, ' (union)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @model.branch_on @set
+
+    @property_types = [:selected_set]
+    @select_property = lambda do |selected_set|
+      selected_set.union
+    end
+    @selected_property = @sets[@set].union
+    @constraint_class = Gecode::BlockConstraint
+  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 translate into a select union constraint' do
+    Gecode::Raw.should_receive(:selectUnion)
+    @sets[@set].union.must_be.subset_of([5,7,9])
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces set operand by short circuiting equality')
+end
+
+describe Gecode::SetEnum::Select, ' (intersection)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @model.branch_on @set
+
+    @property_types = [:selected_set]
+    @select_property = lambda do |selected_set|
+      selected_set.intersection
+    end
+    @selected_property = @sets[@set].intersection
+    @constraint_class = Gecode::BlockConstraint
+  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 translate into a select intersection constraint' do
+    Gecode::Raw.should_receive(:selectInter)
+    @sets[@set].intersection.must_be.subset_of([5,7,9])
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces set operand by short circuiting equality')
+end
+
+describe Gecode::SelectedSet::Select, ' (intersection with universe)' do
+  include GecodeR::Specs::SetHelper
+
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+    @model.branch_on @set
+    @universe = [1,2]
+    
+    @property_types = [:selected_set]
+    @select_property = lambda do |selected_set|
+      selected_set.intersection(:with => @universe)
+    end
+    @selected_property = @sets[@set].intersection(:with => @universe)
+    @constraint_class = Gecode::BlockConstraint
+  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 translate into a select intersection constraint' do
+    Gecode::Raw.should_receive(:selectInterIn)
+    @sets[@set].intersection(:with => 1..2).must_be.subset_of([5,7,9])
+    @model.solve!
+  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(
+    'property that produces set operand by short circuiting equality')
+end
+
+