gecoder-with-gecode 0.9.0-x86-mswin32-60

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

data/specs/constraints/set/operation.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+Gecode::Util::SET_OPERATION_TYPES.each_pair do |operation, type|
+  describe Gecode::Set::Operation, " (#{operation} with set variable)" do
+    before do
+      @model = Gecode::Model.new
+      @set1 = @model.set_var([0], 0..20)
+      @set2 = @model.set_var([1], 0..20)
+      @constant_set = [2, 3, 5]
+      @rhs = @model.set_var([], 0..20)
+      @model.branch_on @model.wrap_enum([@set1, @set2, @rhs])
+    
+      @property_types = [:set, :set]
+      @select_property = lambda do |set1, set2|
+        set1.method(operation).call(set2)
+      end
+      @selected_property = @set1.method(operation).call(@set2)
+      @constraint_class = 
+        Gecode::Set::Operation::OperationConstraint
+    end
+
+    it "should translate #{operation} into an operation constraint" do
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), @set1.bind, type, @set2.bind, 
+          Gecode::Raw::SRT_EQ, @rhs.bind)
+      end
+      @set1.method(operation).call(@set2).must == @rhs
+      @model.solve!
+    end
+
+    it "should constrain the #{operation} of the sets with variable rhs" do
+      @set1.method(operation).call(@set2).must == @rhs
+      @model.solve!
+
+      s1 = @set1.value.to_a
+      s2 = @set2.value.to_a
+      rhs = @rhs.value.to_a
+      case operation
+        when :union
+          (s1 | s2).should == rhs
+        when :disjoint_union
+          (s1 | s2).sort.should == rhs.sort
+        when :intersection
+          (s1 & s2).should == rhs
+        when :minus
+          (s1 - s2).should == rhs
+      end
+    end
+
+    it "should constrain the #{operation} of the sets when used with constant rhs" do
+      if operation == :union || operation == :disjoint_union
+        @constant_set << 0 << 1 # Or there will not be any solution.
+      end
+      @set1.method(operation).call(@set2).must == @constant_set
+      @model.solve!
+
+      s1 = @set1.value.to_a
+      s2 = @set2.value.to_a
+      rhs = @constant_set
+      case operation
+        when :union
+          (s1 | s2).sort.should == rhs.sort
+        when :disjoint_union
+          (s1 | s2).sort.should == rhs.sort
+        when :intersection
+          (s1 & s2).should == rhs
+        when :minus
+          (s1 - s2).should == rhs
+      end
+    end
+    
+    it_should_behave_like(
+      'property that produces set operand by short circuiting set relations')
+  end
+end
+
+Gecode::Util::SET_OPERATION_TYPES.each_pair do |operation, type|
+  describe Gecode::Set::Operation, " (#{operation} with constant set)" do
+    before do
+      @model = Gecode::Model.new
+      @set = @model.set_var([0], 0..20)
+      @constant_set = [1, 3, 5]
+      @rhs = @model.set_var([], 0..20)
+      @model.branch_on @model.wrap_enum([@set, @rhs])
+    
+      @property_types = [:set, :set]
+      @select_property = lambda do |set1, set2|
+        set1.method(operation).call(set2)
+      end
+      @selected_property = @set.method(operation).call(@constant_set)
+      @constraint_class = 
+        Gecode::Set::Operation::OperationConstraint
+    end
+
+    it "should translate #{operation} into an operation constraint" do
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), @set.bind, type, 
+          an_instance_of(Gecode::Raw::IntSet),
+          Gecode::Raw::SRT_EQ, @rhs.bind)
+      end
+      @set.method(operation).call(@constant_set).must == @rhs
+      @model.solve!
+    end
+
+    it "should constrain the #{operation} of the sets with a variable rhs" do
+      @set.method(operation).call(@constant_set).must == @rhs
+      @model.solve!
+
+      s1 = @set.value.to_a
+      s2 = @constant_set
+      rhs = @rhs.value.to_a
+      case operation
+        when :union
+          (s1 | s2).should == rhs
+        when :disjoint_union
+          (s1 | s2).sort.should == rhs.sort
+        when :intersection
+          (s1 & s2).should == rhs
+        when :minus
+          (s1 - s2).should == rhs
+      end
+    end
+
+    # We do not test with a constant rhs since we do not have enough
+    # degrees of freedom to always find a solution.
+
+    it_should_behave_like(
+      'property that produces set operand by short circuiting set relations')
+  end
+end