gecoder-with-gecode 0.8.3 → 0.9.0

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

data/specs/constraints/set/relation.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+Gecode::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+  next if relation == :==
+  
+  describe Gecode::Set::Relation, " (#{relation})" do
+    before do
+      @model = Gecode::Model.new
+      @set = @model.set_var([0], 0..3)
+      @set2 = @model.set_var([1], 0..3)
+      @model.branch_on @model.wrap_enum([@set, @set2])
+      
+      @types = [:set, :set]
+      @invoke = lambda do |receiver, set_op, hash| 
+        receiver.method(relation).call(set_op, hash)
+        @model.solve!
+      end
+      @expect = lambda do |var1, var2, opts, reif_var|
+        if reif_var.nil? 
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var1, type, var2)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var1, type, var2, reif_var)
+        end
+      end
+    end
+
+    it "should correctly constrain the set when #{relation} is used" do
+      @set = @model.set_var if relation == :complement
+      @set.must.method(relation).call(@set2)
+      @model.solve!
+      @set.should be_assigned
+      @set2.should be_assigned
+      case relation
+        when :superset
+          (@set2.value.to_a - @set.value.to_a).should be_empty
+        when :subset
+          (@set.value.to_a - @set2.value.to_a).should be_empty
+        when :complement
+          val = @set.value
+          val.min.should == Gecode::Model::SET_MIN_INT
+          val.max.should == Gecode::Model::SET_MAX_INT
+          @set2.value.each do |element|
+            @set.not_in_upper_bound?(element).should be_true
+          end
+        when :disjoint
+          (@set2.value.to_a & @set.value.to_a).should be_empty
+      end
+    end
+
+    it "should correctly constrain the set when negated #{relation} is used" do
+      @set.must_not.method(relation).call(@set2)
+      @model.solve!
+      @set.should be_assigned
+      @set2.should be_assigned
+      case relation
+        when :superset
+          (@set2.value.to_a - @set.value.to_a).should_not be_empty
+        when :subset
+          (@set.value.to_a - @set2.value.to_a).should_not be_empty
+        when :complement
+          val = @set.value
+          ((val.min != Gecode::Model::SET_MIN_INT) || 
+            (val.max != Gecode::Model::SET_MAX_INT) ||
+            @set.value.to_a.any?{ |element| @set.in_lower_bound?(element) }
+          ).should be_true
+        when :disjoint
+          (@set.value.to_a & @set.value.to_a).should_not be_empty
+      end
+    end
+    
+    it_should_behave_like 'reifiable set constraint'
+  end
+end
+
+describe Gecode::Set::Relation, ' (equality)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([0], 0..1)
+    @set2 = @model.set_var([1], 0..1)
+    @model.branch_on @model.wrap_enum([@set, @set2])
+
+    @types = [:set, :set]
+    @invoke = lambda do |receiver, set_op, hash| 
+      receiver.equal(set_op, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      if reif_var.nil? 
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var1, Gecode::Raw::SRT_EQ, var2)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var1, Gecode::Raw::SRT_EQ, var2, reif_var)
+      end
+    end
+  end
+
+  it 'should constrain sets to be equal' do
+    @set.must == @set2
+    @model.solve!
+    @set.value.to_a.should == @set2.value.to_a
+  end
+  
+  it 'should constrain sets to not be equal when negated' do
+    @set.must_not == @set2
+    @model.solve!
+    @set.value.to_a.should_not == @set2.value.to_a
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+end

data/specs/constraints/set_elements/relation.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+Gecode::Util::RELATION_TYPES.each_pair do |relation, rel_value|
+  describe Gecode::SetElements::Relation, " (#{relation} with int op)" do
+    before do
+      @model = Gecode::Model.new
+      @set = @model.set_var([0], 0..2)
+      @int = @model.int_var(-1..2)
+      @model.branch_on @set
+      @model.branch_on @int
+
+      # For constraint spec.
+      @types = [:set_elements, :int]
+      @invoke = lambda do |receiver, op, hash| 
+        receiver.method(relation).call(op, hash) 
+        @model.solve!
+      end
+      @expect = lambda do |var1, var2, opts, reif_var|
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var1, rel_value, var2)
+      end
+    end
+
+    it "should constrain the elements of the set when #{relation} is used" do
+      @set.elements.must.method(relation).call(@int)
+      @model.solve!
+      @set.value.each do |i|
+        i.should.method(relation).call(@int.value)
+      end
+    end
+
+    it "should constrain the elements of the set when negated #{relation} is used" do
+      @set.elements.must_not.method(relation).call(@int)
+      @model.solve!
+      @set.value.each do |i|
+        i.should_not.method(relation).call(@int.value)
+      end
+    end
+
+    it_should_behave_like 'non-reifiable set constraint'
+  end
+end
+
+Gecode::Util::RELATION_TYPES.each_pair do |relation, rel_value|
+  describe Gecode::SetElements::Relation, " (#{relation} with fixnum)" do
+    before do
+      @model = Gecode::Model.new
+      @set = @model.set_var([], 0..2)
+      @int_constant = 1
+      @model.branch_on @set
+
+      # For constraint spec.
+      @types = [:set_elements]
+      @invoke = lambda do |receiver, hash| 
+        receiver.method(relation).call(@int_constant, hash) 
+        @model.solve!
+      end
+      @expect = lambda do |var1, var2, opts, reif_var|
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var1, rel_value, an_instance_of(Gecode::Raw::IntVar))
+      end
+    end
+
+    it "should constrain the elements of the set when #{relation} is used" do
+      @set.elements.must.method(relation).call(@int_constant)
+      @model.solve!
+      @set.value.each do |i|
+        i.should.method(relation).call(@int_constant)
+      end
+    end
+
+    it "should constrain the elements of the set when negated #{relation} is used" do
+      @set.elements.must_not.method(relation).call(@int_constant)
+      @model.solve!
+      @set.value.each do |i|
+        i.should_not.method(relation).call(@int_constant)
+      end
+    end
+
+    it_should_behave_like 'non-reifiable set constraint'
+  end
+end

data/specs/constraints/set_enum/channel.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class ChannelSampleProblem < Gecode::Model
+  attr :elements
+  attr :positions
+  attr :sets
+  
+  def initialize
+    @elements = int_var_array(4, 0..3)
+    @elements.must_be.distinct
+    @positions = int_var_array(4, 0..3)
+    @positions.must_be.distinct
+    @sets = set_var_array(4, [], 0..3)
+    branch_on @positions
+  end
+end
+
+describe Gecode::SetEnum::Channel::IntEnumChannelConstraint, ' (channel with set as right hand side)' do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @sets = @model.sets
+    
+    @types = [:int_enum, :set_enum]
+    @invoke = lambda do |receiver, set_enum, hash| 
+      receiver.channel(set_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 constrain variables to be channelled' do
+    @positions.must.channel @sets
+    @model.solve!
+    sets = @model.sets
+    positions = @model.positions.values
+    positions.each_with_index do |position, i|
+      sets[position].value.should include(i)
+    end
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::SetEnum::Channel::IntEnumChannelConstraint, ' (channel with set as left hand side)' do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @sets = @model.sets
+    
+    @types = [:set_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.channel(int_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), 
+        var2, var1)
+    end
+  end
+
+  it 'should constrain variables to be channelled' do
+    @sets.must.channel @positions
+    @model.solve!
+    sets = @model.sets
+    positions = @model.positions.values
+    positions.each_with_index do |position, i|
+      sets[position].value.should include(i)
+    end
+  end
+
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/set_enum/distinct.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class SetEnumDistinctSampleProblem < Gecode::Model
+  attr :vars
+  attr :sets
+  
+  def initialize
+    @vars = int_var_array(2, 1)
+    @sets = set_var_array(2, [], 0..2)
+    branch_on @sets
+  end
+end
+
+describe Gecode::SetEnum::Distinct, ' (at most one)' do
+  before do
+    @model = SetEnumDistinctSampleProblem.new
+    @sets = @model.sets
+    @size = 2
+    
+    @types = [:set_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.at_most_share_one_element hash.update(:size => @size)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:atmostOne).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, @size)
+    end
+  end
+
+  it 'should translate into a atmostOne constraint' do
+    Gecode::Raw.should_receive(:atmostOne).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::SetVarArray), @size)
+    @sets.must.at_most_share_one_element(:size => @size)
+    @model.solve!
+  end
+
+  it 'should constrain sets to have at most one element in common' do
+    @sets.must.at_most_share_one_element(:size => @size)
+    @sets[0].must_not_be.superset_of 0
+    solution = @model.solve!
+    solution.should_not be_nil
+    set1, set2 = solution.sets
+    set1.value.size.should == @size
+    set2.value.size.should == @size
+    (set1.value.to_a & set2.value.to_a).size.should <= 1
+  end
+
+  it 'should raise error if :size is not specified' do
+    lambda do
+      @sets.must.at_most_share_one_element 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/set_enum/operation.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+# Assumes that @operation, @set and @set_enum are defined.
+describe 'set enum operation property', :shared => true do
+  before do
+    @property_types = [:set_enum]
+    @select_property = lambda do |set_enum|
+      set_enum.method(@operation).call
+    end
+    @selected_property = @set_enum.method(@operation).call
+
+    @constraint_class = Gecode::BlockConstraint
+  end
+
+  it "should translate #{@operation} into an operand constraint" do
+    operation_type = Gecode::Util::SET_OPERATION_TYPES[@operation]
+    @model.allow_space_access do
+      Gecode::Raw.should_receive(:rel).with(
+        an_instance_of(Gecode::Raw::Space), operation_type, 
+        @set_enum.bind_array, @set.bind)
+    end
+    @set_enum.method(@operation).call.must == @set
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces set operand by short circuiting equality')
+end
+
+describe Gecode::SetEnum::Operation, ' (union)' do
+  before do
+    @model = Gecode::Model.new
+    @set_enum = @sets = @model.set_var_array(10, [], 0..20)
+    @set = @model.set_var([], 0..20)
+    @model.branch_on @sets
+    
+    @operation = :union
+  end
+
+  it 'should constrain the union of the sets' do
+    @sets.union.must_be.subset_of [1,4,17]
+    @sets.union.must_be.superset_of 1
+    @model.solve!.should_not be_nil
+    union = @sets.values.inject([]){ |union, set| union += set.to_a }.uniq
+    union.should include(1)
+    (union - [1,4,17]).should be_empty
+  end
+  
+  it_should_behave_like 'set enum operation property'
+end
+
+describe Gecode::SetEnum::Operation, ' (intersection)' do
+  before do
+    @model = Gecode::Model.new
+    @set_enum = @sets = @model.set_var_array(10, [], 0..20)
+    @set = @model.set_var([], 0..20)
+    @model.branch_on @sets
+    
+    @operation = :intersection
+  end
+
+  it 'should constrain the intersection of the sets' do
+    @sets.intersection.must_be.subset_of [1,4,17]
+    @sets.intersection.must_be.superset_of [1]
+    @model.solve!.should_not be_nil
+    intersection = @sets.values.inject(nil) do |intersection, set|
+      next set.to_a if intersection.nil?
+      intersection &= set.to_a
+    end.uniq
+    intersection.should include(1)
+    (intersection - [1,4,17]).should be_empty
+  end
+  
+  it_should_behave_like 'set enum operation property'
+end
+
+describe Gecode::SetEnum::Operation, ' (disjoint union)' do
+  before do
+    @model = Gecode::Model.new
+    @set_enum = @sets = @model.set_var_array(10, [], 0..20)
+    @set = @model.set_var([], 0..20)
+    @model.branch_on @sets
+    
+    @operation = :disjoint_union
+  end
+
+  it 'should constrain the disjoint union of the sets' do
+    @sets.disjoint_union.must_be.subset_of [1,4,17]
+    @sets.disjoint_union.must_be.superset_of [1]
+    @model.solve!.should_not be_nil
+    disjoint_union = @sets.values.inject([]) do |union, set|
+      unless union.any?{ |x| set.to_a.include? x }
+        union += set.to_a
+      end
+    end.uniq
+    disjoint_union.should include(1)
+    (disjoint_union - [1,4,17]).should be_empty
+  end
+
+  it 'should constrain the disjoint union of the sets (2)' do
+    @sets.disjoint_union.must_be.subset_of [1,4,17]
+    @sets.disjoint_union.must_be.superset_of [1]
+    @sets[0].must_be.superset_of [1]
+    @sets[1].must_be.superset_of [1]
+    lambda do
+      @model.solve!
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+  
+  it_should_behave_like 'set enum operation property'
+end

data/specs/constraints/set_enum/select.rb

@@ -0,0 +1,73 @@
+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
+
+# Requires everything that composite behaviour spec requires in addition to
+# @stub and @expect_constrain_equal .
+describe 'selection constraint', :shared => true do
+  it 'should not disturb normal array access' do
+    @sets[0].should be_kind_of(Gecode::SetVar)
+  end
+end
+
+describe Gecode::SetEnum::Select, ' (int operand)' 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]
+    
+    @property_types = [:set_enum, :int]
+    @select_property = lambda do |set_enum, int|
+      set_enum[int]
+    end
+    @selected_property = @sets[@index]
+    @constraint_class = Gecode::BlockConstraint
+  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 translate into a select constraint' do
+    Gecode::Raw.should_receive(:selectSet)
+    @sets[@index].must_be.superset_of([5,7,9])
+    @model.solve!
+  end
+  
+  it_should_behave_like 'selection constraint'
+  it_should_behave_like(
+    'property that produces set operand by short circuiting equality')
+end
+
+describe Gecode::SetEnum::Select, ' (set operand)' do
+  before do
+    @model = SelectionSampleProblem.new
+    @sets = @model.sets
+    @set = @model.set
+  end
+  
+  it 'should produce a selected set operand' do
+    @sets[@set].should be_respond_to(:to_selected_set)
+  end
+end