gecoder 0.6.1 → 0.7.0

data/lib/gecoder/interface/enum_wrapper.rb

@@ -76,9 +76,10 @@ module Gecode
     # variables involved.
     def domain_range
       inject(nil) do |range, var|
-        next var.min..var.max if range.nil?
         min = var.min
         max = var.max
+        next min..max if range.nil?
+        
         range = min..range.last if min < range.first
         range = range.first..max if max > range.last
         range
@@ -122,6 +123,20 @@ module Gecode
       return @bound_arr
     end
     alias_method :to_var_array, :to_set_var_array
+    
+    # Returns the range of the union of the contained sets' upper bounds.
+    def upper_bound_range
+      inject(nil) do |range, var|
+        upper_bound = var.upper_bound
+        min = upper_bound.min
+        max = upper_bound.max
+        next min..max if range.nil?
+        
+        range = min..range.last if min < range.first
+        range = range.first..max if max > range.last
+        range
+      end
+    end
   end
   
   # A module containing the methods needed by enumerations containing fixnums. 

data/lib/gecoder/interface/model.rb

@@ -67,12 +67,15 @@ module Gecode
     end
     
     # Creates a set variable with the specified domain for greatest lower bound
-    # and least upper bound (specified as either a range or enum). A range for
-    # the allowed cardinality of the set can also be specified, if none is 
-    # specified, or nil is given, then the default range (anything) will be 
-    # used. If only a single Fixnum is specified as cardinality_range then it's
-    # used as lower bound.
-    def set_var(glb_domain, lub_domain, cardinality_range = nil)
+    # and least upper bound (specified as either a range or enum). If no bounds
+    # are specified then the empty set is used as greates lower bound and the 
+    # universe as least upper bound. A range for the allowed cardinality of the 
+    # set can also be specified, if none is specified, or nil is given, then the
+    # default range (anything) will be used. If only a single Fixnum is 
+    # specified as cardinality_range then it's used as lower bound.
+    def set_var(glb_domain = [], lub_domain = 
+        Gecode::Raw::Limits::Set::INT_MIN..Gecode::Raw::Limits::Set::INT_MAX, 
+        cardinality_range = nil)
       check_set_bounds(glb_domain, lub_domain)
       
       index = variable_creation_space.new_set_vars(glb_domain, lub_domain, 
@@ -213,6 +216,7 @@ module Gecode
     # Returns whether the greatest lower bound is a subset of least upper 
     # bound.
     def valid_set_bounds?(glb, lub)
+      return true if glb.respond_to?(:empty?) and glb.empty? 
       if glb.kind_of?(Range) and lub.kind_of?(Range)
         glb.first >= lub.first and glb.last <= lub.last
       else

data/lib/gecoder/interface/search.rb

@@ -4,9 +4,7 @@ module Gecode
     # to that solution. Returns the model if a solution was found, nil 
     # otherwise.
     def solve!
-      GC.disable
       space = dfs_engine.next
-      GC.enable
       return nil if space.nil?
       @active_space = space
       return self
@@ -32,11 +30,9 @@ module Gecode
     # Yields each solution that the model has.
     def each_solution(&block)
       dfs = dfs_engine
-      GC.disable
       while not (@active_space = dfs.next).nil?
         yield self
       end
-      GC.enable
       self.reset!
     end
     
@@ -68,12 +64,10 @@ module Gecode
       end
 
       # Perform the search.
-      GC.disable
       result = Gecode::Raw::bab(selected_space, 
         Gecode::Raw::Search::Config::MINIMAL_DISTANCE, 
         Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
         nil)
-      GC.enable
       
       # Reset the method used constrain calls and return the result.
       Model.constrain_proc = nil

data/lib/gecoder/version.rb

@@ -1,4 +1,4 @@
 module GecodeR
   # A string representation of the Gecode/R version.
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

data/specs/constraints/constraint_helper.rb

@@ -48,10 +48,10 @@ describe 'constraint with options', :shared => true do
 end
 
 # This requires that the constraint spec has the instance variable 
-# @expect_relation which takes a relation and right hand side as arguments and 
-# sets up the corresponding expectations. It also requires @invoke_relation and
-# @invoke_negated_relation with the same arguments. The spec is also required to 
-# provide an int var @target.
+# @expect_relation which takes a relation, right hand side and whether it's 
+# negated as arguments and sets up the corresponding expectations. It also 
+# requires @invoke_relation with the same arguments. The spec is also required 
+# to provide a variable @target.
 describe 'composite constraint', :shared => true do
   Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
     it "should translate #{relation} with constant target" do
@@ -88,6 +88,47 @@ describe 'composite constraint', :shared => true do
   end
 end
 
+# This requires that the constraint spec has the instance variable 
+# @expect_relation which takes a relation, right hand side and whether it's 
+# negated as arguments and sets up the corresponding expectations. It also 
+# requires @invoke_relation with the same arguments. The spec is also required 
+# to provide a variable @target.
+describe 'composite set constraint', :shared => true do
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant target" do
+      @expect_relation.call(type, [1], false)
+      @invoke_relation.call(relation, [1], false)
+    end
+  end
+  
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable target" do
+      @expect_relation.call(type, @target, false)
+      @invoke_relation.call(relation, @target, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant target" do
+      @expect_relation.call(type, [1], true)
+      @invoke_relation.call(relation, [1], true)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable target" do
+      @expect_relation.call(type, @target, true)
+      @invoke_relation.call(relation, @target, true)
+    end
+  end
+
+  it 'should raise error if the target is of the wrong type' do
+    lambda do 
+      @invoke_relation.call(:==, 'hello', false)
+    end.should raise_error(TypeError) 
+  end
+end
+
 # Requires @invoke_options and @model.
 describe 'non-reifiable set constraint', :shared => true do
   it 'should not accept strength option' do

data/specs/constraints/constraints.rb

@@ -54,6 +54,12 @@ describe Gecode::Constraints::Util do
       Gecode::Constraints::Util.constant_set_to_params('hello')
     end.should raise_error(TypeError)
   end
+  
+  it 'should raise error when giving incorrect set to #constant_set_to_int_set' do
+    lambda do 
+      Gecode::Constraints::Util.constant_set_to_int_set('hello')
+    end.should raise_error(TypeError)
+  end
 end
 
 describe Gecode::Constraints::CompositeExpression do

data/specs/constraints/selection.rb

@@ -0,0 +1,292 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+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
+
+# Requires everything that composite behaviour spec requires in addition to
+# @stub and @expect_constrain_equal .
+describe 'selection constraint', :shared => true do
+  before do
+    @expect = lambda do |index, relation, target, reif_var, negated|
+      @model.allow_space_access do
+        if target.respond_to? :bind
+          expected_target = [an_instance_of(Gecode::Raw::SetVar)]
+          relation_constraint = :rel
+        else
+          expected_target = expect_constant_set(target)
+          relation_constraint = :dom
+        end
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              !target.kind_of? Enumerable
+            @expect_constrain_equal.call
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+            Gecode::Raw.should_receive(:dom).exactly(0).times
+          else
+            @expect_constrain_equal.call
+            if relation_constraint == :dom
+              # We can't seem to get any more specific than this with mocks. 
+              Gecode::Raw.should_receive(relation_constraint).at_most(:twice)
+            else
+              Gecode::Raw.should_receive(relation_constraint).once.with(
+                an_instance_of(Gecode::Raw::Space), 
+                an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
+            end
+          end
+        else
+          @expect_constrain_equal.call
+          if relation_constraint == :dom
+            Gecode::Raw.should_receive(relation_constraint).at_least(:twice)
+          else
+            expected_target << an_instance_of(Gecode::Raw::BoolVar)
+            Gecode::Raw.should_receive(relation_constraint).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
+          end
+        end
+      end
+    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(@index, relation, target, nil, negated)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @stub.must_be.subset_of(@target, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(17, Gecode::Raw::SRT_SUB, @target, reif_var, false)
+    end
+  end
+  
+  it 'should not disturb normal array access' do
+    @sets[0].should be_kind_of(Gecode::FreeSetVar)
+  end
+  
+  it_should_behave_like 'reifiable set constraint'
+  it_should_behave_like 'composite set constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (select)' 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]
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectSet).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  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_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (union)' 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])
+    @stub = @sets[@set].union
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectUnion).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  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_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (intersection)' 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])
+    @stub = @sets[@set].intersection
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectInter).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  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_behave_like 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (intersection with universe)' 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])
+    @universe = [1,2]
+    @stub = @sets[@set].intersection(:with => @universe)
+    
+    @expect_constrain_equal = lambda do
+      Gecode::Raw.should_receive(:selectInterIn).once.with( 
+        an_instance_of(Gecode::Raw::Space),
+        an_instance_of(Gecode::Raw::SetVarArray), 
+        an_instance_of(Gecode::Raw::SetVar), 
+        an_instance_of(Gecode::Raw::SetVar),
+        an_instance_of(Gecode::Raw::IntSet))
+    end
+  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 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 'selection constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Selection, ' (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])
+    
+    @expect = lambda do |index|
+      Gecode::Raw.should_receive(:selectDisjoint)
+    end
+    
+    # For options spec.
+    @invoke_options = lambda do |hash|
+      @sets[@set].must_be.disjoint(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@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 not allow negation' do
+    lambda{ @sets[@set].must_not_be.disjoint }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end