gecoder-with-gecode 0.7.1-mswin32 → 0.8.0-mswin32

data/lib/gecoder/interface/constraints/int_enum/count.rb

@@ -67,9 +67,8 @@ module Gecode::Constraints::IntEnum::Count #:nodoc:
   #     :strength => :domain)
   class CountConstraint < Gecode::Constraints::ReifiableConstraint
     def post
-      lhs, element, relation_type, rhs, strength, reif_var = 
-        @params.values_at(:lhs, :element, :relation_type, :rhs, :strength, 
-          :reif)
+      lhs, element, relation_type, rhs, reif_var = 
+        @params.values_at(:lhs, :element, :relation_type, :rhs, :reif)
       
       # Bind variables if needed.
       element = element.bind if element.respond_to? :bind
@@ -78,14 +77,14 @@ module Gecode::Constraints::IntEnum::Count #:nodoc:
       # Post the constraint to gecode.
       if reif_var.nil?
         Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
-          element, relation_type, rhs, strength)
+          element, relation_type, rhs, *propagation_options)
       else
         # We use a proxy int variable to get the reification.
         proxy = @model.int_var(rhs.min..rhs.max)
         rel = Gecode::Constraints::Util::RELATION_TYPES.invert[relation_type]
         proxy.must.send(rel, @params[:rhs], :reify => reif_var)
         Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
-          element, Gecode::Raw::IRT_EQ, proxy.bind, strength)
+          element, Gecode::Raw::IRT_EQ, proxy.bind, *propagation_options)
       end
     end
   end

data/lib/gecoder/interface/constraints/int_enum/distinct.rb

@@ -25,7 +25,11 @@ module Gecode::Constraints::IntEnum
         raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
           'implemented.'
       end
-    
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the distinct ' + 
+          'constraint.'
+      end
+      
       @model.add_constraint Distinct::DistinctConstraint.new(@model, 
         @params.update(Gecode::Constraints::Util.decode_options(options)))
     end
@@ -60,8 +64,9 @@ module Gecode::Constraints::IntEnum
         @params[:lhs] = @params[:lhs].to_int_var_array
         
         # Fetch the parameters to Gecode.
-        params = @params.values_at(:offsets, :lhs, :strength)
+        params = @params.values_at(:offsets, :lhs)
         params.delete_if{ |x| x.nil? }
+        params.concat propagation_options
         Gecode::Raw::distinct(@model.active_space, *params)
       end
     end

data/lib/gecoder/interface/constraints/int_enum/element.rb

@@ -23,7 +23,7 @@ module Gecode::Constraints::IntEnum::Element #:nodoc:
   #   int_enum[x].must_be.in(7..17, :reify => bool, :strength => :domain)
   class ExpressionStub < Gecode::Constraints::Int::CompositeStub
     def constrain_equal(variable, params, constrain)
-      enum, position, strength = @params.values_at(:lhs, :position, :strength)
+      enum, position = @params.values_at(:lhs, :position)
       if constrain
         variable.must_be.in enum.domain_range
       end
@@ -31,7 +31,7 @@ module Gecode::Constraints::IntEnum::Element #:nodoc:
       # The enum can be a constant array.
       enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
       Gecode::Raw::element(@model.active_space, enum, 
-        position.bind, variable.bind, strength)
+        position.bind, variable.bind, *propagation_options)
     end
   end
   

data/lib/gecoder/interface/constraints/int_enum/equality.rb

@@ -8,6 +8,10 @@ module Gecode::Constraints::IntEnum
         raise Gecode::MissingConstraintError, 'A negated equality is not ' + 
           'implemented.'
       end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the equality ' + 
+          'constraint.'
+      end
     
       @model.add_constraint Equality::EqualityConstraint.new(@model, 
         @params.update(Gecode::Constraints::Util.decode_options(options)))
@@ -27,11 +31,10 @@ module Gecode::Constraints::IntEnum
     class EqualityConstraint < Gecode::Constraints::Constraint
       def post
         # Bind lhs.
-        @params[:lhs] = @params[:lhs].to_int_var_array
+        lhs = @params[:lhs].to_int_var_array
         
         # Fetch the parameters to Gecode.
-        params = @params.values_at(:lhs, :strength)
-        Gecode::Raw::eq(@model.active_space, *params)
+        Gecode::Raw::eq(@model.active_space, lhs, *propagation_options)
       end
     end
   end

data/lib/gecoder/interface/constraints/int_enum/sort.rb

@@ -29,6 +29,7 @@ module Gecode::Constraints::IntEnum
       end
       
       # Extract standard options and convert to constraint.
+      reified = !options[:reify].nil?
       @params.update(Gecode::Constraints::Util.decode_options(options))
       if target.nil? and order.nil?
         @model.add_constraint Sort::SortConstraint.new(@model, @params)
@@ -38,6 +39,10 @@ module Gecode::Constraints::IntEnum
           raise Gecode::MissingConstraintError, 'A negated sort with options ' +
             'is not implemented.'
         end
+        if reified
+          raise ArgumentError, 'Reification is not supported by the sorted ' + 
+            'constraint.'
+        end
       
         @params.update(:target => target, :order => order)
         @model.add_constraint Sort::SortConstraintWithOptions.new(@model, 
@@ -72,15 +77,17 @@ module Gecode::Constraints::IntEnum
         end
         
         # Prepare the parameters.
-        params = @params.values_at(:lhs, :target, :order, :strength).map do |param| 
+        params = @params.values_at(:lhs, :target, :order).map do |param| 
           if param.respond_to? :to_int_var_array
             param.to_int_var_array
           else
             param
           end
         end.delete_if{ |param| param.nil? }
+        params.concat propagation_options
+        
         # Post the constraint.
-        Gecode::Raw::sortedness(@model.active_space, *params)
+        Gecode::Raw::sorted(@model.active_space, *params)
       end
     end
     
@@ -98,12 +105,17 @@ module Gecode::Constraints::IntEnum
     #   int_enum.must_be.sorted(:reify => :is_sorted, :strength => :domain)
     class SortConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        lhs, strength, reif_var = @params.values_at(:lhs, :strength, :reif)
+        lhs, strength, kind, reif_var = 
+          @params.values_at(:lhs, :strength, :kind, :reif)
         using_reification = !reif_var.nil?
         
         # We translate the constraint into n-1 relation constraints.
-        options = {:strength => 
-          Gecode::Constraints::Util::PROPAGATION_STRENGTHS.invert[strength]}
+        options = {
+          :strength => 
+            Gecode::Constraints::Util::PROPAGATION_STRENGTHS.invert[strength],
+          :kind => 
+            Gecode::Constraints::Util::PROPAGATION_KINDS.invert[kind]
+        }
         if using_reification
           reification_variables = @model.bool_var_array(lhs.size - 1)
         end

data/lib/gecoder/interface/constraints/set_enum/distinct.rb

@@ -1,24 +1,5 @@
 module Gecode::Constraints::SetEnum
   class Expression
-    # Adds a distinct constraint on the sets in the enum. The "option" :size 
-    # must be specified, the sets will be constrained to that size.
-    def distinct(options = {})
-      unless options.has_key? :size
-        raise ArgumentError, 'Option :size has to be specified.'
-      end
-      unless options.size == 1
-        raise ArgumentError, 'Only the option :size is accepted, got ' + 
-          "#{options.keys.join(', ')}."
-      end
-      if @params[:negate]
-        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
-          'implemented.'
-      end
-      
-      @model.add_constraint Distinct::DistinctConstraint.new(
-        @model, @params.update(options))
-    end
-    
     # Adds a constraint on the sets that specifies that they must have at most
     # one element in common. The "option" :size must be specified, the sets 
     # will be constrained to that size.
@@ -42,23 +23,6 @@ module Gecode::Constraints::SetEnum
   
   # A module that gathers the classes and modules used in distinct constraints.
   module Distinct #:nodoc:
-    # Describes a set distinct constraint, which constrains all set variables
-    # in the enumeration to be distinct and of a specified size. Providing a 
-    # size is not optional.
-    # 
-    # Neither negation nor reification is supported.
-    # 
-    # == Examples
-    # 
-    #   # All set variables in +sets+ must have cardinality 4 and be different.
-    #   sets.must_be.distinct(:size => 4)
-    class DistinctConstraint < Gecode::Constraints::Constraint
-      def post
-        sets, size = @params.values_at(:lhs, :size)
-        Gecode::Raw::distinct(@model.active_space, sets.to_set_var_array, size)
-      end
-    end
-    
     # Describes an at most one constraint, which constrains all pairs of set 
     # variables in the enumeration to at most have one element in common and be 
     # of a specified size. Providing a size is not optional.

data/lib/gecoder/interface/constraints/set_var_constraints.rb

@@ -26,6 +26,11 @@ module Gecode
           raise ArgumentError, 'Set constraints do not support the strength ' +
             'option.'
         end
+        if options.has_key? :kind
+          raise ArgumentError, 'Set constraints do not support the kind ' +
+            'option.'
+        end
+        
         Gecode::Constraints::Util.decode_options(options)
       end
     end

data/lib/gecoder/interface/model.rb

@@ -5,7 +5,7 @@ module Gecode
     # either be a range, a single element, or an enumeration of elements. If no
     # domain is specified then the largest possible domain is used.
     def int_var(domain = 
-        Gecode::Raw::Limits::Int::INT_MIN..Gecode::Raw::Limits::Int::INT_MAX)
+        Gecode::Raw::IntLimits::MIN..Gecode::Raw::IntLimits::MAX)
       enum = domain_enum(domain)
       index = variable_creation_space.new_int_vars(enum).first
       FreeIntVar.new(self, index)
@@ -74,7 +74,7 @@ module Gecode
     # 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, 
+        Gecode::Raw::SetLimits::MIN..Gecode::Raw::SetLimits::MAX, 
         cardinality_range = nil)
       check_set_bounds(glb_domain, lub_domain)
       
@@ -198,7 +198,7 @@ module Gecode
     # otherwise if the argument is a fixnum it's used as lower bound.
     def to_set_cardinality_range(arg)
       if arg.kind_of? Fixnum
-        arg..Gecode::Raw::Limits::Set::CARD_MAX
+        arg..Gecode::Raw::SetLimits::MAX
       else
         arg
       end

data/lib/gecoder/interface/search.rb

@@ -64,10 +64,11 @@ module Gecode
       end
 
       # Perform the search.
-      result = Gecode::Raw::bab(selected_space, 
-        Gecode::Raw::Search::Config::MINIMAL_DISTANCE, 
-        Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
-        nil)
+      options = Gecode::Raw::Search::Options.new
+      options.c_d = Gecode::Raw::Search::Config::MINIMAL_DISTANCE
+      options.a_d = Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE
+      options.stop = nil
+      result = Gecode::Raw::bab(selected_space, options)
       
       # 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.7.1'
+  VERSION = '0.8.0'
 end

data/specs/branch.rb

@@ -22,7 +22,7 @@ describe Gecode::Model, ' (integer branch)' do
   it 'should default to :none and :min' do
     Gecode::Raw.should_receive(:branch).once.with(
       an_instance_of(Gecode::Raw::Space), 
-      anything, Gecode::Raw::BVAR_NONE, Gecode::Raw::BVAL_MIN)
+      anything, Gecode::Raw::INT_VAR_NONE, Gecode::Raw::INT_VAL_MIN)
     @model.branch_on @vars
     @model.solve!
   end
@@ -38,19 +38,19 @@ describe Gecode::Model, ' (integer branch)' do
   end
 
   supported_var_selectors = {
-    :none                 => Gecode::Raw::BVAR_NONE,
-    :smallest_min         => Gecode::Raw::BVAR_MIN_MIN,
-    :largest_min          => Gecode::Raw::BVAR_MIN_MAX, 
-    :smallest_max         => Gecode::Raw::BVAR_MAX_MIN, 
-    :largest_max          => Gecode::Raw::BVAR_MAX_MAX, 
-    :smallest_size        => Gecode::Raw::BVAR_SIZE_MIN, 
-    :largest_size         => Gecode::Raw::BVAR_SIZE_MAX,
-    :smallest_degree      => Gecode::Raw::BVAR_DEGREE_MIN, 
-    :largest_degree       => Gecode::Raw::BVAR_DEGREE_MAX, 
-    :smallest_min_regret  => Gecode::Raw::BVAR_REGRET_MIN_MIN,
-    :largest_min_regret   => Gecode::Raw::BVAR_REGRET_MIN_MAX,
-    :smallest_max_regret  => Gecode::Raw::BVAR_REGRET_MAX_MIN, 
-    :largest_max_regret   => Gecode::Raw::BVAR_REGRET_MAX_MAX
+    :none                 => Gecode::Raw::INT_VAR_NONE,
+    :smallest_min         => Gecode::Raw::INT_VAR_MIN_MIN,
+    :largest_min          => Gecode::Raw::INT_VAR_MIN_MAX, 
+    :smallest_max         => Gecode::Raw::INT_VAR_MAX_MIN, 
+    :largest_max          => Gecode::Raw::INT_VAR_MAX_MAX, 
+    :smallest_size        => Gecode::Raw::INT_VAR_SIZE_MIN, 
+    :largest_size         => Gecode::Raw::INT_VAR_SIZE_MAX,
+    :smallest_degree      => Gecode::Raw::INT_VAR_DEGREE_MIN, 
+    :largest_degree       => Gecode::Raw::INT_VAR_DEGREE_MAX, 
+    :smallest_min_regret  => Gecode::Raw::INT_VAR_REGRET_MIN_MIN,
+    :largest_min_regret   => Gecode::Raw::INT_VAR_REGRET_MIN_MAX,
+    :smallest_max_regret  => Gecode::Raw::INT_VAR_REGRET_MAX_MIN, 
+    :largest_max_regret   => Gecode::Raw::INT_VAR_REGRET_MAX_MAX
   }.each_pair do |name, gecode_const|
     it "should support #{name} as variable selection strategy" do
       Gecode::Raw.should_receive(:branch).once.with(
@@ -62,11 +62,11 @@ describe Gecode::Model, ' (integer branch)' do
   end
 
   supported_val_selectors = {
-    :min        => Gecode::Raw::BVAL_MIN,
-    :med        => Gecode::Raw::BVAL_MED,
-    :max        => Gecode::Raw::BVAL_MAX,
-    :split_min  => Gecode::Raw::BVAL_SPLIT_MIN,
-    :split_max  => Gecode::Raw::BVAL_SPLIT_MAX
+    :min        => Gecode::Raw::INT_VAL_MIN,
+    :med        => Gecode::Raw::INT_VAL_MED,
+    :max        => Gecode::Raw::INT_VAL_MAX,
+    :split_min  => Gecode::Raw::INT_VAL_SPLIT_MIN,
+    :split_max  => Gecode::Raw::INT_VAL_SPLIT_MAX
   }.each_pair do |name, gecode_const|
     it "should support #{name} as value selection strategy" do
       Gecode::Raw.should_receive(:branch).once.with(
@@ -111,7 +111,7 @@ describe Gecode::Model, ' (set branch)' do
   it 'should default to :none and :min' do
     Gecode::Raw.should_receive(:branch).once.with(
       an_instance_of(Gecode::Raw::Space), 
-      anything, Gecode::Raw::SETBVAR_NONE, Gecode::Raw::SETBVAL_MIN)
+      anything, Gecode::Raw::SET_VAR_NONE, Gecode::Raw::SET_VAL_MIN)
     @model.branch_on @sets
     @model.solve!
   end
@@ -122,11 +122,11 @@ describe Gecode::Model, ' (set branch)' do
   end
 
   supported_var_selectors = {
-    :none                 => Gecode::Raw::SETBVAR_NONE,
-    :smallest_cardinality => Gecode::Raw::SETBVAR_MIN_CARD,
-    :largest_cardinality  => Gecode::Raw::SETBVAR_MAX_CARD, 
-    :smallest_unknown     => Gecode::Raw::SETBVAR_MIN_UNKNOWN_ELEM, 
-    :largest_unknown      => Gecode::Raw::SETBVAR_MAX_UNKNOWN_ELEM
+    :none                 => Gecode::Raw::SET_VAR_NONE,
+    :smallest_cardinality => Gecode::Raw::SET_VAR_MIN_CARD,
+    :largest_cardinality  => Gecode::Raw::SET_VAR_MAX_CARD, 
+    :smallest_unknown     => Gecode::Raw::SET_VAR_MIN_UNKNOWN_ELEM, 
+    :largest_unknown      => Gecode::Raw::SET_VAR_MAX_UNKNOWN_ELEM
   }.each_pair do |name, gecode_const|
     it "should support #{name} as variable selection strategy" do
       Gecode::Raw.should_receive(:branch).once.with(
@@ -138,8 +138,8 @@ describe Gecode::Model, ' (set branch)' do
   end
 
   supported_val_selectors = {
-    :min  => Gecode::Raw::SETBVAL_MIN,
-    :max  => Gecode::Raw::SETBVAL_MAX
+    :min  => Gecode::Raw::SET_VAL_MIN,
+    :max  => Gecode::Raw::SET_VAL_MAX
   }.each_pair do |name, gecode_const|
     it "should support #{name} as value selection strategy" do
       Gecode::Raw.should_receive(:branch).once.with(

data/specs/constraints/arithmetic.rb

@@ -25,8 +25,9 @@ describe 'arithmetic constraint', :shared => true do
       @stub.must_be.greater_than(@target, hash) 
       @model.solve!
     end
-    @expect_options = lambda do |strength, reif_var|
-      @expect.call(Gecode::Raw::IRT_GR, @target, strength, reif_var, false)
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      @expect.call(Gecode::Raw::IRT_GR, @target, strength, kind, reif_var, 
+        false)
     end
     
     # For composite spec.
@@ -39,20 +40,21 @@ describe 'arithmetic constraint', :shared => true do
       @model.solve!
     end
     @expect_relation = lambda do |relation, target, negated|
-      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF,
+        nil, negated)
     end
   end
   
   it 'should translate reification when using equality' do
     bool_var = @model.bool_var
-    @expect.call(Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, bool_var, 
-      false)
+    @expect.call(Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, 
+      Gecode::Raw::PK_DEF, bool_var, false)
     @stub.must_be.equal_to(@target, :reify => bool_var)
     @model.solve!
   end
   
   it_should_behave_like 'composite constraint'
-  it_should_behave_like 'constraint with options'
+  it_should_behave_like 'reifiable constraint'
 end
 
 describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
@@ -63,7 +65,7 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
     @stub = @numbers.max
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -71,27 +73,31 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
               !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:max).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              rhs, strength, kind)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:max).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVarArray), 
-              an_instance_of(Gecode::Raw::IntVar), strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              strength, kind)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              relation, rhs, strength, kind)
           end
         else
           Gecode::Raw.should_receive(:max).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
-            an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), 
+            strength, kind)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
             an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            strength, kind)
         end
       end
     end
@@ -113,7 +119,7 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
     @stub = @numbers.min
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
        if reif_var.nil?
@@ -121,27 +127,31 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
               !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:min).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              rhs, strength, kind)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:min).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVarArray), 
-              an_instance_of(Gecode::Raw::IntVar), strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              strength, kind)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              relation, rhs, strength, kind)
           end
         else
           Gecode::Raw.should_receive(:min).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
-            an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), 
+            strength, kind)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
             an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            strength, kind)
         end
       end
     end
@@ -163,7 +173,7 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
     @stub = @var.abs
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -171,26 +181,31 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
               !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:abs).once.with(
               an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::IntVar), rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              rhs, strength, kind)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:abs).once.with(
               an_instance_of(Gecode::Raw::Space),
               an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              strength, kind)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              relation, rhs, strength, kind)
           end
         else
           Gecode::Raw.should_receive(:abs).once.with(
             an_instance_of(Gecode::Raw::Space),
             an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), 
+            strength, kind)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar), strength)
+            an_instance_of(Gecode::Raw::BoolVar), 
+            strength, kind)
         end
       end
     end
@@ -214,7 +229,7 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
     @target = @model.var3
     
     # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, reif_var, negated|
+    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
       @model.allow_space_access do
         rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
@@ -223,7 +238,8 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
             Gecode::Raw.should_receive(:mult).once.with(
               an_instance_of(Gecode::Raw::Space),
               an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              rhs, strength, kind)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:mult).once.with(
@@ -231,22 +247,24 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
               an_instance_of(Gecode::Raw::IntVar), 
               an_instance_of(Gecode::Raw::IntVar), 
               an_instance_of(Gecode::Raw::IntVar), 
-              strength)
+              strength, kind)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              relation, rhs, strength, kind)
           end
         else
           Gecode::Raw.should_receive(:mult).once.with(
             an_instance_of(Gecode::Raw::Space),
             an_instance_of(Gecode::Raw::IntVar), 
             an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), 
+            strength, kind)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
             an_instance_of(Gecode::Raw::BoolVar),
-            strength)
+            strength, kind)
         end
       end
     end