gecoder 0.8.3 → 0.9.0

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
+
+

data/specs/constraints/set/cardinality.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+describe Gecode::Set::Cardinality, ' (constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..10)
+    @model.branch_on @model.wrap_enum([@set])
+    @range = 1..2
+    @three_dot_range = 1...2
+    
+    @invoke = lambda do |rhs| 
+      @set.size.must_be.in(rhs) 
+      @model.solve!
+    end
+    @expect = lambda do |rhs|
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:cardinality).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::SetVar), rhs.first, rhs.last)
+      end
+    end
+  end
+  
+  it 'should translate cardinality constraints with ranges' do
+    @expect.call(@range)
+    @invoke.call(@range)
+  end
+
+  it 'should translate cardinality constraints with three dot range domains' do
+    @expect.call(@three_dot_range)
+    @invoke.call(@three_dot_range)
+  end
+  
+  it 'should constrain the cardinality of a set' do
+    @set.size.must_be.in @range
+    @model.solve!
+    @range.should include(@set.value.size)
+  end
+  
+  it 'should raise error if the right hand side is not a range' do
+    lambda{ @set.size.must_be.in 'hello' }.should raise_error(TypeError)
+  end
+  
+  it 'should not shadow the integer variable domain constrain' do
+    Gecode::Raw.should_receive(:dom).with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), 0, 11, Gecode::Raw::ICL_DEF, 
+      Gecode::Raw::PK_DEF)
+    Gecode::Raw.should_receive(:dom).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), Gecode::Raw::ICL_DEF, 
+      Gecode::Raw::PK_DEF)
+    @set.size.must_not_be.in [1,3]
+    @model.solve!
+  end
+end
+

data/specs/constraints/set/cardinality_properties.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+describe Gecode::Set::Cardinality, ' (property)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..10)
+    @var = @model.int_var(0..11)
+    @model.branch_on @set
+    @model.branch_on @var
+    
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.size
+    end
+    @selected_property = @set.size
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the cardinality of a set' do
+    @set.size.must == @var
+    @model.solve!
+    @set.value.size.should == @var.value
+  end
+  
+  it 'should constrain the cardinality of a set (2)' do
+    @set.size.must == 2
+    @model.solve!.should_not be_nil
+    @set.value.size.should == 2
+  end
+
+  it 'should constrain the cardinality of a set (3)' do
+    @set.size.must == @var
+    @var.must == 2
+    @model.solve!
+    @set.value.size.should == 2
+  end
+
+  it 'should translate into a cardinality constraint' do
+    Gecode::Raw.should_receive(:cardinality)
+    @set.size.must == @var
+    @model.solve!
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end

data/specs/constraints/set/channel.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class SetChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :set
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @set = set_var([], 0..3)
+    
+    branch_on @bool_enum
+  end
+end
+
+describe Gecode::Set::Channel, ' (set variable as lhs with bool enum)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @types = [:set, :bool_enum]
+    @invoke = lambda do |receiver, bool_enum, hash| 
+      receiver.channel(bool_enum, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2)
+    end
+  end
+
+  it 'should channel the bool enum with the set variable' do
+    @set.must_be.superset_of [0, 2]
+    @set.must.channel @bools
+    @model.solve!.should_not be_nil
+    set_values = @set.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == set_values.include?(index)
+    end
+  end
+
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::Set::Channel, ' (bool enum as lhs with set variable)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @types = [:bool_enum, :set]
+    @invoke = lambda do |receiver, set, hash| 
+      receiver.channel(set, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2)
+    end
+  end
+
+  it 'should channel the bool enum with the set variable' do
+    @set.must_be.superset_of [0, 2]
+    @bools.must.channel @set
+    @model.solve!.should_not be_nil
+    set_values = @set.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == set_values.include?(index)
+    end
+  end
+
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/set/connection.rb

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+describe Gecode::Set::Connection, ' (min)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @var = @model.int_var(0..10)
+    @model.branch_on @model.wrap_enum([@set])
+
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.min
+    end
+    @selected_property = @set.min
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the min of a set' do
+    @set.min.must == 3
+    @model.solve!
+    @set.lower_bound.min.should == 3
+  end
+
+  it 'should translate into a min constraint' do
+    Gecode::Raw.should_receive(:min)
+    @set.min.must == 5
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Set::Connection, ' (max)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @var = @model.int_var(0..10)
+    @model.branch_on @model.wrap_enum([@set])
+
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.max
+    end
+    @selected_property = @set.max
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the max of a set' do
+    @set.max.must == 3
+    @model.solve!
+    @set.lower_bound.max.should == 3
+  end
+  
+  it 'should translate into a max constraint' do
+    Gecode::Raw.should_receive(:max)
+    @set.max.must == 5
+    @model.solve!
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Set::Connection, ' (sum)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @target = @var = @model.int_var(0..20)
+    @model.branch_on @model.wrap_enum([@set])
+
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.sum
+    end
+    @selected_property = @set.sum
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the sum of a set' do
+    @set.sum.must == 7
+    @model.solve!.should_not be_nil
+    @set.value.inject(0){ |x, y| x + y }.should == 7
+  end
+
+  it 'should translate into a weights constraint' do
+    Gecode::Raw.should_receive(:weights)
+    @set.sum.must == 5
+    @model.solve!
+  end
+  
+  it 'should raise error if unsupported options is given' do
+    lambda do
+      @set.sum(:does_not_exist => :foo).must == @var 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if multiple options are given' do
+    lambda do
+      @set.sum(:weights => {}, :substitutions => {}).must == @var 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Set::Connection, ' (sum with weights)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @target = @var = @model.int_var(-20..20)
+    @model.branch_on @model.wrap_enum([@set])
+    @weights = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
+  
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.sum(:weights => @weights)
+    end
+    @selected_property = @set.sum(:weights => @weights)
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the sum of a set' do
+    @set.sum(:weights => @weights).must_be.in(-10..-1)
+    @model.solve!.should_not be_nil
+    weighted_sum = @set.value.inject(0){ |sum, x| sum - x**2 }
+    weighted_sum.should >= -10
+    weighted_sum.should <= -1
+  end
+  
+  it 'should remove any elements not in the weight hash' do
+    @set.must_be.superset_of 0
+    @set.sum(:weights => {}).must_be == 0
+    lambda do
+      @model.solve!
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Set::Connection, ' (sum with substitutions)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @target = @var = @model.int_var(-20..20)
+    @model.branch_on @model.wrap_enum([@set])
+    @subs = Hash[*(0..9).zip((-9..-0).to_a.reverse).flatten]
+
+    @property_types = [:set]
+    @select_property = lambda do |set|
+      set.sum(:substitutions => @subs)
+    end
+    @selected_property = @set.sum(:substitutions => @subs)
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the sum of a set' do
+    @set.sum(:substitutions => @subs).must_be.in(-10..-1)
+    @model.solve!.should_not be_nil
+    substituted_sum = @set.value.inject{ |sum, x| sum + @subs[x] }
+    substituted_sum.should >= -10
+    substituted_sum.should <= -1
+  end
+
+  it 'should not be allowed together with :weights option' do
+    lambda do
+      @set.sum(:substitutions => @subs, :weights => [1]*20).must_be.in(-10..-1)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end