gecoder-with-gecode 0.7.1 → 0.8.0

data/lib/gecoder/interface/binding_changes.rb

@@ -274,7 +274,7 @@ module Gecode
         grow(@next_index + count) # See the design note for more information.
 
         if cardinality_range.nil?
-          cardinality_range = 0..Gecode::Raw::Limits::Set::CARD_MAX
+          cardinality_range = 0..Gecode::Raw::SetLimits::CARD
         end
         
         params = [@space]

data/lib/gecoder/interface/branch.rb

@@ -81,44 +81,44 @@ module Gecode
       # Maps the names of the supported variable branch strategies for integer and
       # booleans to the corresponding constant in Gecode. 
       BRANCH_INT_VAR_CONSTANTS = {
-        :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
       }
       # Maps the names of the supported variable branch strategies for sets to 
       # the corresponding constant in Gecode. 
       BRANCH_SET_VAR_CONSTANTS = { #:nodoc:
-        :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
       }
       
       # Maps the names of the supported value branch strategies for integers and
       # booleans to the corresponding constant in Gecode. 
       BRANCH_INT_VALUE_CONSTANTS = { #:nodoc:
-        :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
       }
       # Maps the names of the supported value branch strategies for sets to the 
       # corresponding constant in Gecode. 
       BRANCH_SET_VALUE_CONSTANTS = { #:nodoc:
-        :min  => Gecode::Raw::SETBVAL_MIN,
-        :max  => Gecode::Raw::SETBVAL_MAX
+        :min  => Gecode::Raw::SET_VAL_MIN,
+        :max  => Gecode::Raw::SET_VAL_MAX
       }
     end
     

data/lib/gecoder/interface/constraints.rb

@@ -44,6 +44,14 @@ module Gecode
         :domain   => Gecode::Raw::ICL_DOM
       }
       
+      # Maps the name used in options to the value used in Gecode for 
+      # propagation kinds.
+      PROPAGATION_KINDS = {
+        :default  => Gecode::Raw::PK_DEF,
+        :speed    => Gecode::Raw::PK_SPEED,
+        :memory   => Gecode::Raw::PK_MEMORY,
+      } 
+      
       # Maps the names of the methods to the corresponding integer relation 
       # type in Gecode.
       RELATION_TYPES = { 
@@ -103,9 +111,10 @@ module Gecode
       
       module_function
       
-      # Decodes the common options to constraints: strength and reification. 
-      # Returns a hash with up to two values. :strength is the strength that 
-      # should be used for the constraint and :reif is the (bound) boolean 
+      # Decodes the common options to constraints: strength, kind and 
+      # reification. Returns a hash with up to three values. :strength is the 
+      # strength that should be used for the constraint, :kind is the 
+      # propagation kind that should be used, and :reif is the (bound) boolean 
       # variable that should be used for reification. The decoded options are 
       # removed from the hash (so in general the hash will be consumed in the 
       # process).
@@ -120,6 +129,12 @@ module Gecode
           raise ArgumentError, "Unrecognized propagation strength #{strength}."
         end
         
+        # Propagation kind.
+        kind = options.delete(:kind) || :default
+        unless PROPAGATION_KINDS.include? kind
+          raise ArgumentError, "Unrecognized propagation kind #{kind}."
+        end  
+                      
         # Reification.
         reif_var = options.delete(:reify)
         unless reif_var.nil? or reif_var.kind_of? FreeBoolVar
@@ -131,7 +146,11 @@ module Gecode
           raise ArgumentError, 'Unrecognized constraint option: ' + 
             options.keys.first.to_s
         end
-        return {:strength => PROPAGATION_STRENGTHS[strength], :reif => reif_var}
+        return {
+          :strength => PROPAGATION_STRENGTHS[strength], 
+          :kind => PROPAGATION_KINDS[kind],
+          :reif => reif_var
+        }
       end
       
       # Converts the different ways to specify constant sets in the interface
@@ -188,6 +207,14 @@ module Gecode
           (expression.kind_of?(Enumerable) &&   # It's an enum of fixnums.
            expression.all?{ |e| e.kind_of? Fixnum })
       end
+      
+      # Extracts an array of the values selected for the standard propagation 
+      # options (propagation strength and propagation kind) from the hash of
+      # parameters given. The options are returned in the order that they are 
+      # given when posting constraints to Gecode.      
+      def extract_propagation_options(params)
+        params.values_at(:strength, :kind)
+      end
     end
     
     # Describes a constraint expressions. An expression is produced by calling
@@ -368,6 +395,13 @@ module Gecode
           constrain_equal(var, params, constrain)
         end
       end
+      
+      # Gives an array of the values selected for the standard propagation 
+      # options (propagation strength and propagation kind) in the order that
+      # they are given when posting constraints to Gecode.
+      def propagation_options
+        Gecode::Constraints::Util::extract_propagation_options(@params)
+      end      
     end
     
     # Base class for all constraints.
@@ -384,6 +418,15 @@ module Gecode
       def post
         raise NoMethodError, 'Abstract method has not been implemented.'
       end
+      
+      private
+      
+      # Gives an array of the values selected for the standard propagation 
+      # options (propagation strength and propagation kind) in the order that
+      # they are given when posting constraints to Gecode.
+      def propagation_options
+        Gecode::Constraints::Util::extract_propagation_options(@params)
+      end
     end
   end
 end

data/lib/gecoder/interface/constraints/bool/boolean.rb

@@ -126,8 +126,8 @@ module Gecode
     #   (b1 & b2).must_not.imply b3
     class BooleanConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        lhs, rhs, negate, strength, reif_var = @params.values_at(:lhs, :rhs, 
-          :negate, :strength, :reif)
+        lhs, rhs, negate, reif_var = 
+          @params.values_at(:lhs, :rhs, :negate, :reif)
         space = (lhs.model || rhs.model).active_space
         
         # TODO: It should be possible to reduce the number of necessary 
@@ -136,24 +136,25 @@ module Gecode
         
         if rhs.respond_to? :bind
           if reif_var.nil?
-            Gecode::Raw::bool_eqv(space, lhs.bind, rhs.bind, !negate, strength)
+            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
+              (!negate ? 1 : 0), *propagation_options)
           else
             if negate
-              Gecode::Raw::bool_xor(space, lhs.bind, rhs.bind, reif_var.bind, 
-                strength)
+              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_XOR, rhs.bind, 
+                reif_var.bind, *propagation_options)
             else
-              Gecode::Raw::bool_eqv(space, lhs.bind, rhs.bind, reif_var.bind, 
-                strength)
+              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
+                reif_var.bind, *propagation_options)
             end
           end
         else
           should_hold = !negate & rhs
           if reif_var.nil?
             Gecode::Raw::MiniModel::BoolExpr.new(lhs.bind).post(space, 
-              should_hold)
+              should_hold, *propagation_options)
           else
-            Gecode::Raw::bool_eqv(space, lhs.bind, reif_var.bind, should_hold, 
-              strength)
+            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, 
+              reif_var.bind, (should_hold ? 1 : 0), *propagation_options)
           end
         end
       end
@@ -169,10 +170,10 @@ module Gecode
       # Maps the names of the methods to the corresponding bool constraint in 
       # Gecode.
       OPERATION_TYPES = {
-        :|        => :bool_or,
-        :&        => :bool_and,
-        :^        => :bool_xor,
-        :implies  => :bool_imp
+        :|        => Gecode::Raw::BOT_OR,
+        :&        => Gecode::Raw::BOT_AND,
+        :^        => Gecode::Raw::BOT_XOR,
+        :implies  => Gecode::Raw::BOT_IMP
       }
       
       public
@@ -185,8 +186,9 @@ module Gecode
             end
             ExpressionTree.new(self, expression) do |model, var1, var2|
               new_var = model.bool_var
-              Gecode::Raw::#{operation}(model.active_space, var1.bind, var2.bind,
-                new_var.bind, Gecode::Raw::ICL_DEF)
+              Gecode::Raw::rel(model.active_space, var1.bind, #{operation}, 
+                var2.bind, new_var.bind, Gecode::Raw::ICL_DEF, 
+                Gecode::Raw::PK_DEF)
               new_var
             end
           end

data/lib/gecoder/interface/constraints/bool_enum/boolean.rb

@@ -36,16 +36,16 @@ module Gecode
     #     :strength => :domain)
     class ConjunctionStub < Gecode::Constraints::Bool::CompositeStub
       def constrain_equal(variable, params, constrain)
-        enum, strength = @params.values_at(:lhs, :strength)
+        enum = @params[:lhs]
         
         @model.add_interaction do
           if variable.respond_to? :bind
             bound = variable.bind
           else
-            bound = variable
+            bound = variable ? 1 : 0
           end
-          Gecode::Raw::bool_and(@model.active_space, enum.to_bool_var_array, 
-            bound, strength)
+          Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_AND,
+            enum.to_bool_var_array, bound, *propagation_options)
         end
         return variable
       end
@@ -69,15 +69,17 @@ module Gecode
     #     :strength => :domain)
     class DisjunctionStub < Gecode::Constraints::Bool::CompositeStub
       def constrain_equal(variable, params, constrain)
-        enum, strength = @params.values_at(:lhs, :strength)
+        enum = @params[:lhs]
         
-        if variable.respond_to? :bind
-          bound = variable.bind
-        else
-          bound = variable
+        @model.add_interaction do
+          if variable.respond_to? :bind
+            bound = variable.bind
+          else
+            bound = variable ? 1 : 0
+          end
+          Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_OR,
+            enum.to_bool_var_array, bound, *propagation_options)
         end
-        Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
-          bound, strength)
       end
     end
   end

data/lib/gecoder/interface/constraints/int/arithmetic.rb

@@ -33,13 +33,14 @@ module Gecode::Constraints::Int::Arithmetic #:nodoc:
   #   x.abs.must_be.in(5..7, :reify => bool, :strength => :value)
   class AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
     def constrain_equal(variable, params, constrain)
-      lhs, strength = @params.values_at(:lhs, :strength)
+      lhs = @params[:lhs]
       if constrain
         bounds = [lhs.min.abs, lhs.max.abs]
         variable.must_be.in bounds.min..bounds.max
       end
       
-      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
+      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, 
+        *propagation_options)
     end
   end
   
@@ -56,7 +57,7 @@ module Gecode::Constraints::Int::Arithmetic #:nodoc:
   #   (x*y).must_be.less_than(17, :reify => bool, :strength => :domain)
   class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
     def constrain_equal(variable, params, constrain)
-      lhs, lhs2, strength = @params.values_at(:lhs, :var, :strength)
+      lhs, lhs2 = @params.values_at(:lhs, :var)
       if constrain
         a_min = lhs.min; a_max = lhs.max
         b_min = lhs2.min; b_max = lhs2.max
@@ -65,7 +66,7 @@ module Gecode::Constraints::Int::Arithmetic #:nodoc:
       end
 
       Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
-        variable.bind, strength)
+        variable.bind, *propagation_options)
     end
   end
 end

data/lib/gecoder/interface/constraints/int/domain.rb

@@ -34,12 +34,13 @@ module Gecode::Constraints::Int
     #   x.must_not_be.in(-5...5, :reify => bool, :strength => :value)
     class RangeDomainConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        var, domain, reif_var, strength = @params.values_at(:lhs, :domain, 
-          :reif, :strength)
+        var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
+          
         (params = []) << var.bind
         params << domain.first << domain.last
         params << reif_var.bind if reif_var.respond_to? :bind
-        params << strength
+        params.concat propagation_options
+        
         Gecode::Raw::dom(@model.active_space, *params)
       end
       negate_using_reification
@@ -61,16 +62,14 @@ module Gecode::Constraints::Int
     #   x.must_not_be.in(-[5,6,7,17], :reify => bool, :strength => :value)
     class EnumDomainConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        space = @model.active_space
-      
-        var, domain, reif_var, strength = @params.values_at(:lhs, :domain, 
-          :reif, :strength)
+        var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
         
         (params = []) << var.bind
         params << Gecode::Constraints::Util.constant_set_to_int_set(domain)
         params << reif_var.bind if reif_var.respond_to? :bind
-        params << strength
-        Gecode::Raw::dom(space, *params)
+        params.concat propagation_options
+        
+        Gecode::Raw::dom(@model.active_space, *params)
       end
       negate_using_reification
     end

data/lib/gecoder/interface/constraints/int/linear.rb

@@ -141,8 +141,8 @@ module Gecode
     #   (x + y)*10.must_not_be.greater_than(x*3, :reify => bool, :strength => :domain)
     class LinearConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        lhs, rhs, relation_type, reif_var, strength = @params.values_at(:lhs, 
-          :rhs, :relation_type, :reif, :strength)
+        lhs, rhs, relation_type, reif_var = 
+          @params.values_at(:lhs, :rhs, :relation_type, :reif)
         reif_var = reif_var.bind if reif_var.respond_to? :bind
         if rhs.respond_to? :to_minimodel_lin_exp
           rhs = rhs.to_minimodel_lin_exp
@@ -152,9 +152,11 @@ module Gecode
 
         final_exp = (lhs.to_minimodel_lin_exp - rhs)
         if reif_var.nil?
-          final_exp.post(@model.active_space, relation_type, strength)
+          final_exp.post(@model.active_space, relation_type, 
+            *propagation_options)
         else
-          final_exp.post(@model.active_space, relation_type, reif_var)
+          final_exp.post(@model.active_space, relation_type, reif_var, 
+            *propagation_options)
         end
       end
     end
@@ -199,16 +201,16 @@ module Gecode
     class SimpleRelationConstraint < Gecode::Constraints::ReifiableConstraint
       def post
         # Fetch the parameters to Gecode.
-        lhs, relation, rhs, reif_var, strength = @params.values_at(:lhs, 
-          :relation_type, :element, :reif, :strength)
+        lhs, relation, rhs, reif_var = 
+          @params.values_at(:lhs, :relation_type, :element, :reif)
           
         rhs = rhs.bind if rhs.respond_to? :bind
         if reif_var.nil?
           Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
-            strength)
+            *propagation_options)
         else
           Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
-            reif_var.bind, strength)
+            reif_var.bind, *propagation_options)
         end
       end
     end

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

@@ -33,13 +33,13 @@ module Gecode::Constraints::IntEnum::Arithmetic #:nodoc:
   #     :strength => :domain)
   class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
     def constrain_equal(variable, params, constrain)
-      enum, strength = @params.values_at(:lhs, :strength)
+      enum = @params[:lhs]
       if constrain
         variable.must_be.in enum.domain_range
       end
       
       Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
-        variable.bind, strength)
+        variable.bind, *propagation_options)
     end
   end
   
@@ -60,13 +60,13 @@ module Gecode::Constraints::IntEnum::Arithmetic #:nodoc:
   #     :strength => :domain)
   class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
     def constrain_equal(variable, params, constrain)
-      enum, strength = @params.values_at(:lhs, :strength)
+      enum = @params[:lhs]
       if constrain
         variable.must_be.in enum.domain_range
       end
       
       Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
-        variable.bind, strength)
+        variable.bind, *propagation_options)
     end
   end
 end

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

@@ -83,13 +83,13 @@ module Gecode::Constraints::IntEnum
     #   set_enum.must.channel int_enum
     class ChannelConstraint < Gecode::Constraints::Constraint
       def post
-        lhs, rhs, strength = @params.values_at(:lhs, :rhs, :strength)
+        lhs, rhs = @params.values_at(:lhs, :rhs)
       
         lhs = lhs.to_int_var_array
         if rhs.respond_to? :to_int_var_array
           # Int var array.
           Gecode::Raw::channel(@model.active_space, lhs, rhs.to_int_var_array,
-            strength)
+            *propagation_options)
         else
           # Set var array, no strength.
           Gecode::Raw::channel(@model.active_space, lhs, rhs.to_set_var_array)