gecoder-with-gecode 0.8.2-mswin32 → 0.8.3-mswin32

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

@@ -35,19 +35,7 @@ module Gecode::Constraints::Int
     #            set to k then the integer variable takes value i+k exactly 
     #            when the variable at index i in the boolean enumration is true 
     #            and the rest are false.
-    def channel(bool_enum, options = {})
-      unless bool_enum.respond_to? :to_bool_var_array
-        raise TypeError, 'Expected an enumration of boolean variables, got ' + 
-          "#{bool_enum.class}."
-      end
-      
-      # Just provide commutivity with the boolean enum channel constraint.
-      if @params[:negate]
-        bool_enum.must_not.channel(@params[:lhs], options)
-      else
-        bool_enum.must.channel(@params[:lhs], options)
-      end
-    end
+    provide_commutivity(:channel){ |rhs, _| rhs.respond_to? :to_bool_var_array }
   end
   
   # A module that gathers the classes and modules used in channel constraints

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

@@ -7,23 +7,20 @@ module Gecode::Constraints::IntEnum
         raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
           'is not implemented.'
       end
-      unless enum.respond_to?(:to_int_var_array) or 
-          enum.respond_to?(:to_set_var_array)
-        raise TypeError, "Expected int or set enum, got #{enum.class}."
+      unless enum.respond_to?(:to_int_var_array)
+        raise TypeError, "Expected int enum, got #{enum.class}."
       end
-      if enum.respond_to? :to_set_var_array
-        if options.has_key? :reify
-          raise ArgumentError, 'The channel constraints does not support the ' +
-            'reification option.'
-        end
-        @params.update(Gecode::Constraints::Set::Util.decode_options(options))
-      else
-        @params.update(Gecode::Constraints::Util.decode_options(options))
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraints does not support the ' +
+          'reification option.'
       end
       
+      @params.update(Gecode::Constraints::Util.decode_options(options))
       @params.update(:rhs => enum)
       @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
     end
+    
+    provide_commutivity(:channel){ |rhs, _| rhs.respond_to? :to_set_var_array }
   end
   
   # A module that gathers the classes and modules used in channel constraints.
@@ -33,14 +30,12 @@ module Gecode::Constraints::IntEnum
     # enumeration of set variables. Channel constraints are used to give 
     # access to multiple viewpoints when modelling. 
     # 
-    # When used on two integer enumeration, the channel constraint can be 
-    # thought of as constraining the arrays to be each other's inverses. When 
-    # used with an enumeration of sets the i:th set includes the value of the
-    # j:th integer.  
+    # The channel constraint can be thought of as constraining the arrays to 
+    # be each other's inverses. I.e. if the i:th value in the first enumeration
+    # is j, then the j:th value in the second enumeration is constrained to be 
+    # i.
     # 
-    # Neither reification nor negation is supported. Selecting strength is only 
-    # supported when using the constraint between two integer enumerations, 
-    # it's not supported when a set enumeration is used.  
+    # Neither reification nor negation is supported.
     # 
     # == Example
     # 
@@ -82,26 +77,11 @@ module Gecode::Constraints::IntEnum
     # 
     #   elements.must.channel positions
     # 
-    # == Example (sets)
-    # 
-    #   # +set_enum+ is constrained to channel +int_enum+.
-    #   int_enum.must.channel set_enum
-    # 
-    #   # This is another way of saying the above.
-    #   set_enum.must.channel int_enum
     class ChannelConstraint < Gecode::Constraints::Constraint
       def post
         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,
-            *propagation_options)
-        else
-          # Set var array, no propagation options.
-          Gecode::Raw::channel(@model.active_space, lhs, rhs.to_set_var_array)
-        end
+        Gecode::Raw::channel(@model.active_space, lhs.to_int_var_array, 
+          rhs.to_int_var_array, *propagation_options)
       end
     end
   end

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

@@ -26,6 +26,27 @@ module Gecode::Constraints::IntEnum
       @model.add_constraint Extensional::TupleConstraint.new(@model, 
         @params.update(util.decode_options(options)))
     end
+
+    # Adds a constraint that forces the enumeration to match the
+    # specified regular expression over the integer domain. The regular
+    # expression is expressed using arrays and integers. See
+    # IntEnum::Extensional::RegexpConstraint for more information and examples of
+    # such regexps.
+    def match(regexp, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
+          'is not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the regexp ' + 
+          'constraint.'
+      end
+
+      @params[:regexp] = 
+        Gecode::Constraints::Util::Extensional.parse_regexp regexp
+      @params.update Gecode::Constraints::Util.decode_options(options)
+      @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
+    end
   end
   
   # A module that gathers the classes and modules used in extensional 
@@ -60,5 +81,114 @@ module Gecode::Constraints::IntEnum
           *propagation_options)
       end
     end
+
+    # Describes a regexp constraint, which constrains the enumeration of
+    # integer variables to match a specified regexp in the integer
+    # domain. Neither negation nor reification is supported.
+    #
+    # == Regexp syntax
+    #
+    # The regular expressions are specified using arrays, integers and a
+    # few methods provided by Model. Arrays are used to group the
+    # integers in sequences that must be matched. The following array
+    # describes a regular expression matching a 1 followed by a 7.
+    #
+    #   [1, 7]
+    #
+    # Arrays can be nested or left out when not needed. I.e. the above
+    # is semantically equal to
+    #
+    #   [[[1], 7]]
+    #
+    # A couple of methods provided by Model are used to express patterns 
+    # beyond mere sequences:
+    #
+    # [Model#repeat] Used for specifying patterns that include patterns
+    #                that may be repeated a given number of times. The 
+    #                number of times to repeat a pattern can be specified 
+    #                using a lower and upper bound, but the bounds can be 
+    #                omitted to for instance allow an expression to be 
+    #                repeated any number of times.
+    # [Model#any]    Used for specifying alternatives.
+    # 
+    # Additionally Model#at_least_once and Model#at_most_once are
+    # provided as convenience methods.
+    #
+    # === Examples
+    #
+    #   # Matches 1 followed by any number of 2s.
+    #   [1, repeat(2)]
+    #
+    #   # Semantically the same as above. It just has a bunch of
+    #   # needless brackets thrown in.
+    #   [[1], [repeat([2])]]
+    #
+    #   # Matches 1 followed by [a 2 followed by a 3] at least two times.
+    #   # Matches e.g. 1, 2, 3, 2, 3
+    #   [1, repeat([2, 3], 2)]
+    #
+    #   # Matches between one and two [2 followed by [at least three 1]] 
+    #   # followed by between three and four 3. Matches e.g. 
+    #   # 2, 1, 1, 1, 2, 1, 1, 1, 3, 3, 3
+    #   [repeat([2, repeat(1, 3], 1, 2), repeat(3, 3, 4)]
+    #
+    #   # Matches [1, 2 or 3] followed by 4. Matches e.g. 2, 4
+    #   [any(1, 2, 3), 4]
+    #
+    #   # Matches 0 followed by [[1 followed by 2] or [3 followed by 5]]. 
+    #   # Matches e.g. 0, 1, 2 as well as 0, 3, 5
+    #   [0, any([1, 2], [3, 5])]
+    #
+    #   # Matches 0 followed by [[[1 followed by 7] at least two times] 
+    #   # or [[8, 9], at most two times]. Matches e.g. 
+    #   # 0, 1, 7, 1, 7, 1, 7 as well as 0, 8, 9
+    #   [0, any(repeat([1, 7], 2), repeat([8, 9], 0, 2)]
+    #
+    #   # Matches 0 followed by at least one 1.
+    #   [0, at_least_once(1)]
+    #
+    #   # Exactly the same as the above.
+    #   [0, repeat(1, 1)]
+    #
+    #   # Matches 0 followed by at least one [[1 followed by 7] or [3
+    #   # followed by 2]]. Matches e.g. 0, 1, 7, 3, 2, 1, 7
+    #   [0, at_least_once(any([1, 7], [3, 2]]
+    #
+    #   # Matches 0 followed by at either [[1 followed by 7] at least once] 
+    #   # or [[3 followed by 2] at least once]. Matches e.g. 
+    #   # 0, 1, 7, 1, 7 but does _not_ match 0, 1, 7, 3, 2, 1, 7
+    #   [0, any(at_least_once([1, 7]), at_least_once([3, 2])]
+    #
+    #   # Matches 0, followed by at most one 1. Matches 0 as well as 
+    #   # 0, 1
+    #   [0, at_most_once(1)]
+    #
+    #   # Exactly the same as the above.
+    #   [0, repeat(1, 0, 1)]
+    #
+    # == Example
+    #
+    #   # Constrains the two integer variables in +numbers+ to have
+    #   # values 1 and 7.
+    #   numbers.must.match [1, 7]
+    #
+    #   # Constrains the integer variables in +numbers+ to contain the
+    #   # value 47 followed by 11, with all other values set to -1.
+    #   numbers.must.match [repeat(-1), 47, 11, repeat(-1)]
+    #
+    #   # Constrains exactly three of the integer variables in +numbers+ to 
+    #   # contain 47 or 11, each followed by at least two
+    #   # variables set to -1. All other variables are constrained to
+    #   # equal -1.
+    #   numbers.must.match repeat([repeat(-1), any(11, 47), 
+    #                              repeat(-1, 2)], 3, 3)
+    #
+    class RegexpConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, regexp = @params.values_at(:lhs, :regexp)
+        Gecode::Raw::extensional(@model.active_space, lhs.to_int_var_array, 
+          regexp, *propagation_options)
+      end
+    end
   end
 end

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

@@ -0,0 +1,54 @@
+module Gecode::Constraints::Set
+  class Expression
+    # Adds a channel constraint on the set variable with the specified enum of 
+    # boolean variables.
+    def channel(bool_enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraint does not support the ' + 
+          'reification option.'
+      end
+      unless bool_enum.respond_to? :to_bool_var_array
+        raise TypeError, 'Expected an enum of bool variables, ' + 
+          "got #{bool_enum.class}."
+      end
+      
+      @params.update(:rhs => bool_enum)
+      @params.update Gecode::Constraints::Set::Util.decode_options(options)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints
+  # involving one set variable and a boolean enum.
+  module Channel #:nodoc:
+    # Describes a channel constraint that "channels" a set variable and an
+    # enumerations of boolean variables. This constrains the set variable to
+    # include value i exactly when the variable at index i in the boolean
+    # enumeration is true.
+    # 
+    # Neither reification nor negation is supported. The boolean enum and set
+    # can be interchanged.
+    #
+    # == Examples
+    #
+    # # Constrains the enumeration of boolean variables called +bools+ to at
+    # # least have the first and third variables set to true 
+    # set.must_be.superset_of [0, 2]
+    # set.must.channel bools
+    #
+    # # An alternative way of writing the above.
+    # set.must_be.superset_of [0, 2]
+    # bools.must.channel set
+    class ChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, rhs.to_bool_var_array, 
+          lhs.bind)
+      end
+    end
+  end
+end

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

@@ -2,16 +2,47 @@ module Gecode::Constraints::SetEnum
   class Expression
     # Posts a channel constraint on the variables in the enum with the specified
     # int enum.
-    def channel(enum)
+    def channel(enum, options = {})
       unless enum.respond_to? :to_int_var_array
         raise TypeError, "Expected integer variable enum, for #{enum.class}."
       end
-      
-      # Just provide commutativity to the corresponding int enum constraint.
       if @params[:negate]
-        enum.must_not.channel(@params[:lhs])
-      else
-        enum.must.channel(@params[:lhs])
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraints does not support the ' +
+          'reification option.'
+      end
+      
+      @params.update(Gecode::Constraints::Set::Util.decode_options(options))
+      @params.update(:rhs => enum)
+      @model.add_constraint Channel::IntChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints.
+  module Channel #:nodoc:
+    # Describes a channel constraint which "channels" one enumeration of 
+    # integer variables with one enumeration of set variables. The i:th set 
+    # in the enumeration of set variables is constrainde to includes the value 
+    # of the j:th integer variable. 
+    # 
+    # Neither reification nor negation is supported.
+    # 
+    # == Examples
+    # 
+    #   # +set_enum+ is constrained to channel +int_enum+.
+    #   int_enum.must.channel set_enum
+    # 
+    #   # This is another way of saying the above.
+    #   set_enum.must.channel int_enum
+    #
+    class IntChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, rhs.to_int_var_array, 
+          lhs.to_set_var_array)
       end
     end
   end

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

@@ -75,3 +75,4 @@ require 'gecoder/interface/constraints/set/relation'
 require 'gecoder/interface/constraints/set/cardinality'
 require 'gecoder/interface/constraints/set/connection'
 require 'gecoder/interface/constraints/set/operation'
+require 'gecoder/interface/constraints/set/channel'

data/lib/gecoder/interface/model.rb

@@ -1,117 +1,109 @@
 module Gecode
   # Model is the base class that all models must inherit from.
   class Model
+    # The largest integer allowed in the domain of an integer variable.
+    MAX_INT = Gecode::Raw::IntLimits::MAX
+    # The smallest integer allowed in the domain of an integer variable.
+    MIN_INT = Gecode::Raw::IntLimits::MIN
+
+    # The largest integer allowed in the domain of a set variable.
+    SET_MAX_INT = Gecode::Raw::SetLimits::MAX
+    # The smallest integer allowed in the domain of a set variable.
+    SET_MIN_INT = Gecode::Raw::SetLimits::MIN
+
+    # The largest possible domain for an integer variable.
+    LARGEST_INT_DOMAIN = MIN_INT..MAX_INT
+    # The largest possible domain, without negative integers, for an
+    # integer variable.
+    NON_NEGATIVE_INT_DOMAIN = 0..MAX_INT
+
+    # The largest possible bound for a set variable.
+    LARGEST_SET_BOUND = SET_MIN_INT..SET_MAX_INT
+
     # Creates a new integer variable with the specified domain. The domain can
     # 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::IntLimits::MIN..Gecode::Raw::IntLimits::MAX)
-      enum = domain_enum(domain)
-      index = variable_creation_space.new_int_vars(enum).first
-      FreeIntVar.new(self, index)
+    def int_var(domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
     end
     
     # Creates an array containing the specified number of integer variables 
     # with the specified domain. The domain can either be a range, a single 
-    # element, or an enumeration of elements. 
-    def int_var_array(count, domain)
-      enum = domain_enum(domain)
-      variables = []
-      variable_creation_space.new_int_vars(enum, count).each do |index|
-        variables << FreeIntVar.new(self, index)
+    # element, or an enumeration of elements. If no domain is specified then 
+    # the largest possible domain is used.
+    def int_var_array(count, domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      build_var_array(count) do
+        FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number rows and columns of 
     # integer variables with the specified domain. The domain can either be a 
-    # range, a single element, or an enumeration of elements. 
-    def int_var_matrix(row_count, col_count, domain)
-      enum = domain_enum(domain)
-      indices = variable_creation_space.new_int_vars(enum, row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeIntVar.new(self, index)
-        end
+    # range, a single element, or an enumeration of elements. If no domain 
+    # is specified then the largest possible domain is used.
+    def int_var_matrix(row_count, col_count, domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      build_var_matrix(row_count, col_count) do
+        FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Creates a new boolean variable.
     def bool_var
-      index = variable_creation_space.new_bool_vars.first
-      FreeBoolVar.new(self, index)
+      FreeBoolVar.new(self, variable_creation_space.new_bool_var)
     end
     
     # Creates an array containing the specified number of boolean variables.
     def bool_var_array(count)
-      variables = []
-      variable_creation_space.new_bool_vars(count).each do |index|
-        variables << FreeBoolVar.new(self, index)
+      build_var_array(count) do
+        FreeBoolVar.new(self, variable_creation_space.new_bool_var)
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number rows and columns of 
     # boolean variables.
     def bool_var_matrix(row_count, col_count)
-      indices = variable_creation_space.new_bool_vars(row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeBoolVar.new(self, index)
-        end
+      build_var_matrix(row_count, col_count) do
+        FreeBoolVar.new(self, variable_creation_space.new_bool_var)
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Creates a set variable with the specified domain for greatest lower bound
     # and least upper bound (specified as either a fixnum, 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 
+    # no bounds are specified then the empty set is used as greatest lower 
+    # bound and the largest possible set 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::SetLimits::MIN..Gecode::Raw::SetLimits::MAX, 
+    def set_var(glb_domain = [], lub_domain = LARGEST_SET_BOUND,
         cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      index = variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-        to_set_cardinality_range(cardinality_range)).first
-      FreeSetVar.new(self, index)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
     end
     
     # Creates an array containing the specified number of set variables. The
     # parameters beyond count are the same as for #set_var .
-    def set_var_array(count, glb_domain, lub_domain, cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      variables = []
-      variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-          to_set_cardinality_range(cardinality_range), count).each do |index|
-        variables << FreeSetVar.new(self, index)
+    def set_var_array(count, glb_domain = [], lub_domain = LARGEST_SET_BOUND, 
+        cardinality_range = nil)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      build_var_array(count) do
+        FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number of rows and columns 
     # filled with set variables. The parameters beyond row and column counts are
     # the same as for #set_var .
-    def set_var_matrix(row_count, col_count, glb_domain, lub_domain, 
-        cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      indices = variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-        to_set_cardinality_range(cardinality_range), row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeSetVar.new(self, index)
-        end
+    def set_var_matrix(row_count, col_count, glb_domain = [], 
+        lub_domain = LARGEST_SET_BOUND, cardinality_range = nil)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      build_var_matrix(row_count, col_count) do
+        FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Retrieves the currently used space. Calling this method is only allowed 
@@ -176,20 +168,49 @@ module Gecode
     
     private
     
-    # Returns an enumeration of the specified domain arguments, which can 
-    # either be given as a range, a single number, or an enumerable of elements. 
-    def domain_enum(domain)
+    # Creates an array containing the specified number of variables, all
+    # constructed using the provided block..
+    def build_var_array(count, &block)
+      variables = []
+      count.times do 
+        variables << yield
+      end
+      return wrap_enum(variables)
+    end
+    
+    # Creates a matrix containing the specified number rows and columns of 
+    # variables, all constructed using the provided block. 
+    def build_var_matrix(row_count, col_count, &block)
+      rows = []
+      row_count.times do |i|
+        row = []
+        col_count.times do |j|
+          row << yield
+        end
+        rows << row
+      end
+      return wrap_enum(Util::EnumMatrix.rows(rows, false))
+    end
+
+    # Returns the array of arguments that correspond to the specified 
+    # domain when given to Gecode. The domain can be given as a range, 
+    # a single number, or an enumerable of elements. 
+    def domain_arguments(domain)
       if domain.respond_to?(:first) and domain.respond_to?(:last) and
             domain.respond_to?(:exclude_end?)
         if domain.exclude_end?
-          return domain.first..(domain.last - 1)
+          return [domain.first, (domain.last - 1)]
         else
-          return domain
+          return [domain.first, domain.last]
         end
       elsif domain.kind_of? Enumerable
-        return domain
+        array = domain.to_a
+        return [Gecode::Raw::IntSet.new(array, array.size)]
+      elsif domain.kind_of? Fixnum
+        return [domain, domain]
       else
-        return domain..domain
+        raise TypeError, 'The domain must be given as an instance of ' +
+          "Enumerable or Fixnum, but #{domain.class} was given."
       end
     end
     
@@ -204,6 +225,21 @@ module Gecode
       end
     end
     
+    # Converts the specified set var domain to parameters accepted by
+    # Gecode. The bounds can be specified as a fixnum, range or # enum. 
+    # The parameters are returned as an array.
+    def set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      check_set_bounds(glb_domain, lub_domain)
+      args = []
+      args << Gecode::Constraints::Util.constant_set_to_int_set(glb_domain)
+      args << Gecode::Constraints::Util.constant_set_to_int_set(lub_domain)
+      card_range = to_set_cardinality_range(cardinality_range)
+      if card_range.nil?
+        card_range = 0..Gecode::Raw::SetLimits::CARD
+      end
+      args << card_range.first << card_range.last
+    end
+    
     # Checks whether the specified greatest lower bound is a subset of least 
     # upper bound. Raises ArgumentError if that is not the case.
     def check_set_bounds(glb, lub)
@@ -243,15 +279,6 @@ module Gecode
       @variable_creation_space || selected_space
     end
     
-    # Refreshes all cached variables. This should be called if the variables
-    # in an existing space were changed.
-    def refresh_variables
-      return if @variables.nil?
-      @variables.each do |variable|
-        variable.refresh if variable.cached?
-      end
-    end
-    
     # Executes any interactions with Gecode still waiting in the queue 
     # (emptying the queue) in the process.
     def perform_queued_gecode_interactions
@@ -266,8 +293,6 @@ module Gecode
     # assigned directly.
     def active_space=(new_space)
       @active_space = new_space
-      new_space.refresh
-      refresh_variables
     end    
   end
-end
+end