gecoder 0.8.3 → 0.9.0

data/specs/constraints/bool_enum/channel.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class BoolChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :bool
+  attr :int
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @int = int_var(0..3)
+    @bool = bool_var
+    
+    branch_on @int
+  end
+end
+
+describe Gecode::BoolEnum::Channel, ' (bool enum as lhs with int variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+
+    @types = [:bool_enum, :int]
+    @invoke = lambda do |receiver, int, hash| 
+      receiver.channel(int, 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, 0, *opts)
+    end
+  end
+
+  it 'should channel the bool enum with the integer variable' do
+    @int.must > 2
+    @bools.must.channel @int
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index == int_val)
+    end
+  end
+  
+  it 'should take the offset into account when channeling' do
+    @int.must > 2
+    offset = 1
+    @bools.must.channel(@int, :offset => offset)
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index + offset == int_val)
+    end
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+
+describe Gecode::BoolEnum::Channel, ' (int variable as lhs with bool enum)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+
+    @types = [:int, :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), 
+        var2, var1, 0, *opts)
+    end
+  end
+
+  it 'should channel the bool enum with the integer variable' do
+    @int.must > 2
+    @int.must.channel @bools
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index == int_val)
+    end
+  end
+  
+  it 'should take the offset into account when channeling' do
+    @int.must > 2
+    offset = 1
+    @int.must.channel(@bools, :offset => offset)
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index + offset == int_val)
+    end
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/{extensional.rb → bool_enum/extensional.rb}

@@ -1,21 +1,7 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
+require File.dirname(__FILE__) + '/../constraint_helper'
 
 # Assumes that @variables, @expected_array and @tuples are defined.
-describe 'tuple constraint', :shared => true do
-  before do
-    @invoke_options = lambda do |hash| 
-      @variables.must_be.in(@tuples, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:extensional).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        @expected_array, 
-        an_instance_of(Gecode::Raw::TupleSet), strength, kind)
-    end
-  end
-  
+describe 'bool tuple constraint', :shared => true do
   it 'should not allow negation' do
     lambda do 
       @variables.must_not_be.in @tuples
@@ -40,51 +26,26 @@ describe 'tuple constraint', :shared => true do
       @variables.must_be.in ['h'*size, 'i'*size] 
     end.should raise_error(TypeError)
   end
-  
-  it_should_behave_like 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::IntEnum::Extensional, ' (tuple constraint)' do
-  before do
-    @model = Gecode::Model.new
-    @tuples = [[1,7], [5,1]]
-    @variables = @digits = @model.int_var_array(2, 0..9)
-    @model.branch_on @digits
-    
-    @expected_array = an_instance_of Gecode::Raw::IntVarArray
-  end
-  
-  it 'should constrain the domain of all variables' do
-    @digits.must_be.in @tuples
-    
-    found_solutions = []
-    @model.each_solution do |m|
-      found_solutions << @digits.values
-    end
-    
-    found_solutions.size.should == 2
-    (found_solutions - @tuples).should be_empty
-  end
-  
-  it 'should raise error if the right hand side is not an enumeration' do
-    lambda{ @digits.must_be.in 4711 }.should raise_error(TypeError)
-  end
-  
-  it 'should raise error if the right hand side does not contain tuples' do
-    lambda{ @digits.must_be.in [17, 4711] }.should raise_error(TypeError)
-  end
-  
-  it_should_behave_like 'tuple constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
+describe Gecode::BoolEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[true, false, true], [false, false, true]]
     @variables = @bools = @model.bool_var_array(3)
     @model.branch_on @bools
     
-    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
+    @types = [:bool_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.in([[true, false, true, false, true], 
+                  [false, true, true, true, true]], hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, an_instance_of(Gecode::Raw::TupleSet), *opts)
+    end
   end
   
   it 'should constrain the domain of all variables' do
@@ -107,25 +68,14 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
     lambda{ @bools.must_be.in [true, false] }.should raise_error(TypeError)
   end
   
-  it_should_behave_like 'tuple constraint'
+  it_should_behave_like 'bool tuple constraint'
+  it_should_behave_like 'non-reifiable constraint'
 end
 
+
 # Assumes that @variables, @expected_array, @value1, @value2 (must not
 # equal @value1) and @regexp are defined. 
-describe 'regular expression constraint', :shared => true do
-  before do
-    @invoke_options = lambda do |hash| 
-      @variables.must.match(@regexp, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:extensional).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        @expected_array, 
-        an_instance_of(Gecode::Raw::REG), strength, kind)
-    end
-  end
-
+describe 'bool regular expression constraint', :shared => true do
   it 'should handle values grouped in a single array' do
     @variables.must.match [@value1, @value2, @value1]
     @model.solve!.should_not be_nil
@@ -231,40 +181,9 @@ describe 'regular expression constraint', :shared => true do
       @variables.must_not.match @regexp
     end.should raise_error(Gecode::MissingConstraintError)
   end
-
-  it_should_behave_like 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::IntEnum::Extensional, ' (regexp constraint)' do
-  before do
-    @model = Gecode::Model.new
-    @variables = @digits = @model.int_var_array(3, 0..9)
-    @model.branch_on @digits
-    @expected_array = an_instance_of Gecode::Raw::IntVarArray
-    @value1 = 3
-    @value2 = 5
-    @regexp = [1, @model.any(3, 4), @model.at_most_once(5)]
-  end
-
-  it 'should handle the any operation' do
-    @digits.must.match [1, @model.any(1, 2, 3), 3]
-    @model.solve!.should_not be_nil
-    values = @digits.values
-    values.size.should == 3 
-    values.should == values.sort
-  end
-
-  it 'should handle the any operator with nested expressions' do
-    @digits.must.match [1, @model.any(@model.at_least_once(2), [3, 5])]
-    @digits[2].must < 4
-    @model.solve!.should_not be_nil
-    @digits.values.should == [1,2,2]
-  end
-
-  it_should_behave_like 'regular expression constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
+describe Gecode::BoolEnum::Extensional, ' (regexp constraint)' do
   before do
     @model = Gecode::Model.new
     @variables = @bools = @model.bool_var_array(3)
@@ -273,6 +192,17 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
     @value1 = true
     @value2 = false
     @regexp = [true, @model.any(true, false), @model.at_most_once(true)]
+
+    @types = [:bool_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.match(@regexp, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, an_instance_of(Gecode::Raw::REG), *opts)
+    end
   end
 
   it 'should handle the any operation' do
@@ -290,5 +220,6 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
     @bools.values.should == [true, true, true]
   end
 
-  it_should_behave_like 'regular expression constraint'
+  it_should_behave_like 'bool regular expression constraint'
+  it_should_behave_like 'non-reifiable constraint'
 end

data/specs/constraints/constraint_helper.rb

@@ -1,264 +1,234 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-# Several of these shared specs requires one or more of the following instance 
-# variables to be used: 
-# [@expect_options]  A method that creates an expectation on the aspect to be 
-#                    tested, using the provided hash of Gecode values. The hash 
-#                    can have values for the keys :icl (ICL_*), :pk (PK_*), and 
-#                    :bool (bound reification variable). Any values not 
-#                    provided are assumed to be default values (nil in the case 
-#                    of :bool).
-# [@invoke_options]  A method that invokes the aspect to be tested, with the 
-#                    provided hash of options (with at most the keys :strength, 
-#                    :kind and :reify).
+# Every constraint should have a spec that specs the following:
+#
+# * An example where the constraint is used to constrain a sample
+# problem (and one for negation if deemed necessary).
+# * should_behave_like [non-reifiable|reifiable] constraint (possibly
+# indirect).
+# * Those constraints that do not support negation must
+# should_behave_like 'non-negatable constraint'
+#
+
+
+# These specs assume that the following variables are defined:
+# [@expect]          A proc that creates an expectation corresponding to
+#                    constraint. It should take three parameter. The
+#                    first is an array of operands of types specified by
+#                    @types. The second is whether or not the constraint
+#                    should be negated. The third is a hash that can
+#                    have values for the keys :icl (ICL_*), :pk (PK_*),
+#                    and :bool (bound reification variable). Any values
+#                    not provided are assumed to be default values (nil
+#                    in the case of :bool).
+# [@invoke]          A proc that invokes the constraint to be tested, It 
+#                    should have arity arity(@types) + 1. The first
+#                    parameter is a constraint receiver (type decided by 
+#                    @types). The next arity(@types)-1 parameters are 
+#                    given operands of types specified by @types. The
+#                    last parameter is a hash of options (with at most
+#                    the keys :strength, :kind and :reify)..
+# [@types]           An array of symbols signaling what types of
+#                    arguments @ accepts. The symbols
+#                    must be one of: :int, :bool, :set, :int_enum,
+#                    :bool_enum, :set_enum, :fixnum_enum.
 # [@model]           The model instance that contains the aspects being tested.
-# [@expect_relation] A method that takes a relation, right hand side, and 
-#                    whether it's negated, as arguments and sets up the 
-#                    corresponding expectations. 
-# [@invoke_relation] A method that takes a relation, right hand side, and 
-#                    whether it's negated, as arguments and adds the 
-#                    corresponding constraint and invokes it.
-# [@target]          A legal right hand side that can be used as argument to 
-#                    the above two methods.
 
-
-# Requires @invoke_options and @expect_options.
-describe 'constraint with strength option', :shared => true do
-  { :default  => Gecode::Raw::ICL_DEF,
-    :value    => Gecode::Raw::ICL_VAL,
-    :bounds   => Gecode::Raw::ICL_BND,
-    :domain   => Gecode::Raw::ICL_DOM
-  }.each_pair do |name, gecode_value|
-    it "should translate propagation strength #{name}" do
-      @expect_options.call(:icl => gecode_value)
-      @invoke_options.call(:strength => name)
+def expect(variables, options)
+  bool = options[:bool]
+  bool = @model.allow_space_access{ bool.bind } unless bool.nil?
+  args = @model.allow_space_access do 
+    variables.map do |var| 
+      if var.respond_to? :bind
+        var.bind
+      else
+        var.bind_array
+      end
     end
   end
-  
-  it 'should default to using default as propagation strength' do
-    @expect_options.call({})
-    @invoke_options.call({})
+  args << [options[:icl] || Gecode::Raw::ICL_DEF,
+           options[:pk]  || Gecode::Raw::PK_DEF]
+  args << bool
+  @expect.call(*args)
+end
+
+def invoke(operands, options)
+  base_op = operands.first
+  if options.delete(:negate)
+    receiver = base_op.must_not
+  else
+    receiver = base_op.must
   end
-  
-  it 'should raise errors for unrecognized propagation strengths' do
+  args = ([receiver] + operands[1..-1]) << options
+  @invoke.call(*args)
+end
+
+describe 'reifiable constraint', :shared => true do
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint with reification option'
+  it_should_behave_like 'constraint'
+end
+
+describe 'non-reifiable constraint', :shared => true do
+  it 'should raise errors if reification is used' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:strength => :does_not_exist) 
+      invoke(operands, :reify => @model.bool_var)
     end.should raise_error(ArgumentError)
   end
+
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint'
 end
 
-# Requires @invoke_options and @expect_options.
-describe 'constraint with kind option', :shared => true do
-  { :default  => Gecode::Raw::PK_DEF,
-    :speed    => Gecode::Raw::PK_SPEED,
-    :memory   => Gecode::Raw::PK_MEMORY
-  }.each_pair do |name, gecode_value|
-    it "should translate propagation kind #{name}" do
-      @expect_options.call(:pk => gecode_value)
-      @invoke_options.call(:kind => name)
-    end
-  end
-  
-  it 'should default to using default as propagation kind' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  end
-  
-  it 'should raise errors for unrecognized propagation kinds' do
+describe 'non-negatable constraint', :shared => true do
+  it 'should raise errors if negation is used' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:kind => :does_not_exist)
-    end.should raise_error(ArgumentError)
+      invoke(operands, :negate => true)
+    end.should raise_error(Gecode::MissingConstraintError)
   end
 end
 
+describe 'constraint', :shared => true do
+  it 'should raise errors if parameters of the incorrect type are given' do
+    operands, variables = produce_general_arguments(@types)
+    (1...operands.size).each do |i|
+      bogus_operands = operands.clone
+      bogus_operands[i] = Object.new
+      lambda do
+        invoke(bogus_operands, {})
+      end.should raise_error(TypeError)
+    end
+  end
+end
 
-# Requires @invoke_options and @expect_options.
 describe 'constraint with reification option', :shared => true do
   it 'should translate reification' do
+    operands, variables = produce_general_arguments(@types)
     var = @model.bool_var
-    @expect_options.call(:bool => var)
-    @invoke_options.call(:reify => var)
+    expect(variables, :bool => var)
+    invoke(operands, :reify => var)
+  end
+
+  it 'should translate reification with arbitrary bool operand' do
+    operands, variables = produce_general_arguments(@types)
+    op, bool_var = general_bool_operand(@model)
+    expect(variables, :bool => bool_var)
+    invoke(operands, :reify => op)
   end
   
   it 'should raise errors for reification variables of incorrect type' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => 'foo')
+      invoke(operands, :reify => 'foo')
     end.should raise_error(TypeError)
   end
 end
 
-# Requires @invoke_options and @expect_options.
-describe 'reifiable constraint', :shared => true do
-  it_should_behave_like 'constraint with default options'
-  it_should_behave_like 'constraint with reification option'
-end
-
-# Requires @invoke_options, @expect_options and @model.
-describe 'non-reifiable constraint', :shared => true do
-  it 'should raise errors if reification is used' do
+describe 'constraint with default options', :shared => true do
+  it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => @model.bool_var)
+      invoke(operands, :does_not_exist => :foo) 
     end.should raise_error(ArgumentError)
   end
-  
-  it_should_behave_like 'constraint with default options'
-end
 
-# Requires @invoke_options and @expect_options.
-describe 'constraint with default options', :shared => true do
-  it 'should raise errors for unrecognized options' do
-    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
-      raise_error(ArgumentError))
-  end
-  
   it_should_behave_like 'constraint with strength option'
   it_should_behave_like 'constraint with kind option'
 end
 
-# Requires @expect_relation, @invoke_relation and @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
-      @expect_relation.call(type, 1, false)
-      @invoke_relation.call(relation, 1, false)
-    end
-  end
-  
-  Gecode::Constraints::Util::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)
+describe 'constraint with strength option', :shared => true do
+  { :default  => Gecode::Raw::ICL_DEF,
+    :value    => Gecode::Raw::ICL_VAL,
+    :bounds   => Gecode::Raw::ICL_BND,
+    :domain   => Gecode::Raw::ICL_DOM
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation strength #{name}" do
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :icl => gecode_value)
+      invoke(operands, :strength => name)
     end
   end
   
-  Gecode::Constraints::Util::NEGATED_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
+  it 'should default to using default as propagation strength' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
   end
   
-  Gecode::Constraints::Util::NEGATED_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
+  it 'should raise errors for unrecognized propagation strengths' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_relation.call(:==, 'hello', false)
-    end.should raise_error(TypeError) 
+      invoke(operands, :strength => :does_not_exist) 
+    end.should raise_error(ArgumentError)
   end
 end
 
-# Requires @expect_relation, @invoke_relation and @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)
+describe 'constraint with kind option', :shared => true do
+  { :default  => Gecode::Raw::PK_DEF,
+    :speed    => Gecode::Raw::PK_SPEED,
+    :memory   => Gecode::Raw::PK_MEMORY
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation kind #{name}" do
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :pk => gecode_value)
+      invoke(operands, :kind => name)
     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
+  it 'should default to using default as propagation kind' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
   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
+  it 'should raise errors for unrecognized propagation kinds' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_relation.call(:==, 'hello', false)
-    end.should raise_error(TypeError) 
+      invoke(operands, :kind => :does_not_exist)
+    end.should raise_error(ArgumentError)
   end
 end
 
 describe 'set constraint', :shared => true do
   it 'should not accept strength option' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:strength => :default)
+      invoke(operands, :strength => :default)
     end.should raise_error(ArgumentError)
   end
   
   it 'should not accept kind option' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:kind => :default)
+      invoke(operands, :kind => :default)
     end.should raise_error(ArgumentError)
   end
   
   it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:does_not_exist => :foo) 
+      invoke(operands, :does_not_exist => :foo) 
     end.should raise_error(ArgumentError)
   end
+
+  it_should_behave_like 'constraint'
 end
 
-# Requires @invoke_options and @model.
 describe 'non-reifiable set constraint', :shared => true do
   it 'should not accept reification option' do
     bool = @model.bool_var
+    operands, variables = produce_general_arguments(@types)
     lambda do 
-      @invoke_options.call(:reify => bool)
+      invoke(operands, :reify => bool)
     end.should raise_error(ArgumentError)
   end
   
   it_should_behave_like 'set constraint'
 end
 
-# Requires @invoke_options, @expect_options and @model.
 describe 'reifiable set constraint', :shared => true do
   it_should_behave_like 'set constraint'
   it_should_behave_like 'constraint with reification option'
 end
-
-# Help methods for the GecodeR specs. 
-module GecodeR::Specs
-  module SetHelper
-    module_function
-  
-    # Returns the arguments that should be used in a partial mock to expect the
-    # specified constant set (possibly an array of arguments).
-    def expect_constant_set(constant_set)
-      if constant_set.kind_of? Range
-        return constant_set.first, constant_set.last
-      elsif constant_set.kind_of? Fixnum
-        constant_set
-      else
-        an_instance_of(Gecode::Raw::IntSet)
-      end
-    end
-  end
-end
-
-# Helper for creating @expect_option. Creates a method which takes a hash that
-# may have values for the keys :icl (ICL_*), :pk (PK_*), and :bool (reification 
-# variable). Expectations corresponding to the hash values are given to the 
-# specified block in the order of icl, pk and bool. Default values are provided 
-# if the hash doesn't specify anything else.
-def option_expectation(&block)
-  lambda do |hash|
-    bool = hash[:bool]
-    # We loosen the expectation some to avoid practical problems with expecting
-    # specific variables not under our control.
-    bool = an_instance_of(Gecode::Raw::BoolVar) unless bool.nil?
-    yield(hash[:icl] || Gecode::Raw::ICL_DEF,
-      hash[:pk]  || Gecode::Raw::PK_DEF,
-      bool)
-  end
-end