gecoder 0.5.0 → 0.6.0

data/specs/constraints/connection.rb

@@ -0,0 +1,352 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+# Requires @expect, @model, @stub, @target.
+describe 'connection constraint', :shared => true do
+  before do
+    @invoke = lambda do |rhs| 
+      @stub.must == rhs 
+      @model.solve!
+    end
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @stub.must_not.send(relation, target)
+      else
+        @stub.must.send(relation, target)
+      end
+      @model.solve!
+    end
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @stub.must_be.less_than_or_equal_to(17, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::IRT_LQ, 17, strength, reif_var, false)
+    end
+  end
+  
+  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'composite constraint'
+end
+
+describe Gecode::Constraints::Set::Connection, ' (min)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @target = @var = @model.int_var(0..10)
+    @model.branch_on @model.wrap_enum([@set])
+    @stub = @set.min
+    
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:min).once.with( 
+              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:min).once.with(
+              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
+        else
+          Gecode::Raw.should_receive(:min).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the min of a set' do
+    @set.min.must == @var
+    @model.solve!
+    @set.lower_bound.min.should == @var.value
+  end
+  
+  it_should_behave_like 'connection constraint'
+end
+
+describe Gecode::Constraints::Set::Connection, ' (max)' do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..9)
+    @target = @var = @model.int_var(0..10)
+    @model.branch_on @model.wrap_enum([@set])
+    @stub = @set.max
+    
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:max).once.with( 
+              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:max).once.with(
+              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
+        else
+          Gecode::Raw.should_receive(:max).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the max of a set' do
+    @set.max.must == @var
+    @model.solve!
+    @set.lower_bound.max.should == @var.value
+  end
+  
+  it_should_behave_like 'connection constraint'
+end
+
+describe Gecode::Constraints::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])
+    @stub = @set.sum
+    
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:weights).once.with( 
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:weights).once.with(
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
+        else
+          Gecode::Raw.should_receive(:weights).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the sum of a set' do
+    @set.sum.must == @var
+    @model.solve!.should_not be_nil
+    @set.value.inject(0){ |x, y| x + y }.should == @var.value
+  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 'connection constraint'
+end
+
+describe Gecode::Constraints::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]
+    @stub = @set.sum(:weights => @weights)
+    
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:weights).once.with( 
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:weights).once.with(
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
+        else
+          Gecode::Raw.should_receive(:weights).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the sum of a set' do
+    @stub.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.sum(:weights => {}).must_be == 0
+    @model.solve!.should_not be_nil
+    @set.value.size.should be_zero
+  end
+  
+  it_should_behave_like 'connection constraint'
+end
+
+describe Gecode::Constraints::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]
+    @stub = @set.sum(:substitutions => @subs)
+    
+    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:weights).once.with( 
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, rhs)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:weights).once.with(
+              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::IntVar))
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+              strength)
+          end
+        else
+          Gecode::Raw.should_receive(:weights).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the sum of a set' do
+    @stub.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_behave_like 'connection constraint'
+end
+
+describe Gecode::Constraints::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])
+    
+    @expect = lambda do |rhs, strength, reif_var|
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:match).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          @set.bind, an_instance_of(Gecode::Raw::IntVarArray))
+      end
+    end
+    
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@array, strength, reif_var)
+    end
+    @invoke_options = lambda do |hash|
+      @set.must.include(@array, hash)
+      @model.solve!
+    end
+  end
+  
+  it 'should translate to a match constraint' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @set.must.include @array
+    @model.solve!
+  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 raise error if the right hand side is not an array of variables' do
+    lambda{ @set.must.include 'hello' }.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if negated' do
+    lambda{ @set.must_not.include @array }.should raise_error(
+      Gecode::MissingConstraintError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end

data/specs/constraints/constraints.rb

@@ -9,7 +9,7 @@ describe Gecode::Constraints::Expression do
 end
 
 describe Gecode::Constraints::IntEnum::Expression do
-  it 'should raise error unless lhs is an enum' do
+  it 'should raise error unless lhs is an int enum' do
     lambda do
       Gecode::Constraints::IntEnum::Expression.new(Gecode::Model.new, 
         :lhs => 'foo', :negate => false)
@@ -17,6 +17,15 @@ describe Gecode::Constraints::IntEnum::Expression do
   end
 end
 
+describe Gecode::Constraints::SetEnum::Expression do
+  it 'should raise error unless lhs is a set enum' do
+    lambda do
+      Gecode::Constraints::SetEnum::Expression.new(Gecode::Model.new, 
+        :lhs => 'foo', :negate => false)
+    end.should raise_error(TypeError)
+  end
+end
+
 describe Gecode::Constraints::Int::CompositeStub, ' (not subclassed)' do
   before do
     @con = Gecode::Constraints::Int::CompositeStub.new(Gecode::Model.new, {})

data/specs/constraints/count.rb

@@ -23,20 +23,25 @@ describe Gecode::Constraints::IntEnum::Count do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |element, relation, target, strength, reif_var|
-      target = target.bind if target.respond_to? :bind
-      element = element.bind if element.respond_to? :bind
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:count).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          element, relation, target, strength)
-      else
-        Gecode::Raw.should_receive(:count).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          element, Gecode::Raw::IRT_EQ,
-          an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation,
-          target, reif_var.bind, strength)
+      @model.allow_space_access do
+        target = target.bind if target.respond_to? :bind
+        element = element.bind if element.respond_to? :bind
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:count).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, relation, target, strength)
+        else
+          Gecode::Raw.should_receive(:count).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, Gecode::Raw::IRT_EQ,
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation,
+            target, reif_var.bind, strength)
+        end
       end
     end
     
@@ -50,32 +55,67 @@ describe Gecode::Constraints::IntEnum::Count do
     end
   end
 
-  # Various situations that must be handled, nil denotes that a variable should
-  # be used.
-  situations = {
-    'variable element and target' => [nil, nil],
-    'variable element and constant target' => [nil, 2],
-    'constant element and variable target' => [1, nil],
-    'constant element and constant target' => [1, 2]
-  }.each_pair do |description, element_and_target|
-    element, target = element_and_target
-    Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-      it "should translate #{relation} with #{description}" do
-        element = @element if element.nil?
-        target = @target if target.nil?
-        @expect.call(element, type, target, Gecode::Raw::ICL_DEF, nil)
-        @list.count(element).must.send(relation, target)
-        @model.solve!
-      end
+  # Various situations that must be handled (4*2 in total). This was originally
+  # written without the repetition (r269), but that interfered with the spec 
+  # somehow.
+
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable element and target" do
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must.send(relation, @target)
+      @model.solve!
     end
-    Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-      it "should translate negated #{relation} with #{description}" do
-        element = @element if element.nil?
-        target = @target if target.nil?
-        @expect.call(element, type, target, Gecode::Raw::ICL_DEF, nil)
-        @list.count(element).must_not.send(relation, target)
-        @model.solve!
-      end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable element and target" do
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must_not.send(relation, @target)
+      @model.solve!
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable element and constant target" do
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must.send(relation, 2)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable element and constant target" do
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must_not.send(relation, 2)
+      @model.solve!
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant element and constant target" do
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must.send(relation, 2)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant element and constant target" do
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must_not.send(relation, 2)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant element and variable target" do
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must.send(relation, @target)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant element and variable target" do
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must_not.send(relation, @target)
+      @model.solve!
     end
   end