gecoder-with-gecode 0.8.3 → 0.9.0

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

data/specs/constraints/set/domain.rb

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+Gecode::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+  next if relation == :==
+  
+  describe Gecode::Set::Domain, " (#{relation})" do
+    include GecodeR::Specs::SetHelper
+
+    before do
+      @model = Gecode::Model.new
+      @glb = []
+      @lub = 0..3
+      @set = @model.set_var(@glb, @lub)
+      @model.branch_on @set
+      @range = 0..1
+      @non_range = [0, 2]
+      @singleton = 0
+      
+      @types = [:set]
+      @invoke = lambda do |receiver, hash| 
+        receiver.method(relation).call(@non_range, hash)
+        @model.solve!
+      end
+      @expect = lambda do |var, opts, reif_var|
+        @expect_with_rhs.call(var, opts, reif_var, @non_range)
+      end
+      @expect_with_rhs = lambda do |var, opts, reif_var, rhs|
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var, type, 
+            *expect_constant_set(rhs))
+        else
+          params = [an_instance_of(Gecode::Raw::Space), 
+            var, type]
+          params << expect_constant_set(rhs)
+          params << reif_var
+          Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+        end
+      end
+    end
+  
+    it "should translate #{relation} with constant range to domain constraint" do
+      @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+        nil, nil, @range)
+      @set.must.send(relation, @range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant non-range to domain constraint" do
+      @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+        nil, nil, @non_range)
+      @set.must.send(relation, @non_range)
+      @model.solve!
+    end
+    
+    it "should translate #{relation} with constant singleton to domain constraint" do
+      @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+        nil, nil, @singleton)
+      @set.must.send(relation, @singleton)
+      @model.solve!
+    end
+  
+    it 'should raise error if the right hand side is not a constant set' do
+      lambda do
+        @set.must.send(relation, 'not a constant set')
+      end.should raise_error(TypeError)
+    end
+
+    it "should constrain the domain when #{relation} is used" do
+      @set = @model.set_var if relation == :complement
+      @set.must.method(relation).call(@non_range)
+      @model.solve!
+      @set.should be_assigned
+      case relation
+        when :superset
+          (@non_range - @set.value.to_a).should be_empty
+        when :subset
+          (@set.value.to_a - @non_range).should be_empty
+        when :complement
+          val = @set.value
+          val.min.should == Gecode::Model::SET_MIN_INT
+          val.max.should == Gecode::Model::SET_MAX_INT
+          @non_range.each do |element|
+            @set.not_in_upper_bound?(element).should be_true
+          end
+        when :disjoint
+          (@non_range & @set.value.to_a).should be_empty
+      end
+    end
+
+    it "should constrain the domain when negated #{relation} is used" do
+      @set.must_not.method(relation).call(@non_range)
+      @model.solve!
+      @set.should be_assigned
+      case relation
+        when :superset
+          (@non_range - @set.value.to_a).should_not be_empty
+        when :subset
+          (@set.value.to_a - @non_range).should_not be_empty
+        when :complement
+          val = @set.value
+          ((val.min != Gecode::Model::SET_MIN_INT) || 
+            (val.max != Gecode::Model::SET_MAX_INT) ||
+            @non_range.any?{ |element| @set.in_lower_bound?(element) }
+          ).should be_true
+        when :disjoint
+          (@non_range & @set.value.to_a).should_not be_empty
+      end
+    end
+
+    it_should_behave_like 'reifiable set constraint'
+  end
+end
+
+describe Gecode::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
+    @model.branch_on @model.wrap_enum([@set])
+    
+    @types = [:set]
+    @invoke = lambda do |receiver, hash| 
+      receiver.equal(@non_range, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      @expect_with_rhs.call(var, opts, reif_var, @non_range)
+    end
+    @expect_with_rhs = lambda do |var, opts, reif_var, rhs|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:dom).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var, Gecode::Raw::SRT_EQ, 
+          *expect_constant_set(rhs))
+      else
+        params = [an_instance_of(Gecode::Raw::Space), 
+          var, Gecode::Raw::SRT_EQ]
+        params << expect_constant_set(rhs)
+        params << reif_var
+        Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+      end
+    end
+  end
+  
+  it 'should translate equality with constant range to domain constraint' do
+    @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+      nil, nil, @range)
+    @set.must == @range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant non-range to domain constraint' do
+    @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+      nil, nil, @non_range)
+    @set.must == @non_range
+    @model.solve!
+  end
+  
+  it 'should translate equality with constant singleton to domain constraint' do
+    @expect_with_rhs.call(@model.allow_space_access{ @set.bind }, 
+      nil, nil, @singleton)
+    @set.must == @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!
+    @set.should be_assigned
+    @set.value.should include(@singleton)
+    ((@set.value.size > 1) || (@set.value != [@singleton])).should be_true
+  end
+
+  it 'should raise error if the right hand side is not a constant set' do
+    lambda do
+      @set.must == 'not a constant set'
+    end.should raise_error(TypeError)
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end

data/specs/constraints/set/include.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+describe Gecode::Set::Connection, ' (include)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 2..5)
+    @array = @model.int_var_array(4, 0..9)
+    @array.must_be.distinct
+    @model.branch_on @array
+    #@model.branch_on @model.wrap_enum([@set])
+
+    @types = [:set, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      if hash.empty?
+        receiver.include(int_enum)
+      else
+        receiver.include(int_enum, hash)
+      end
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:match).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2)
+    end
+  end
+  
+  it 'should constrain the variables to be included in the set' do
+    @set.must.include @array
+    @model.solve!.should_not be_nil
+    @array.all?{ |x| @set.lower_bound.include? x.value }.should be_true
+  end
+ 
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end