gecoder 0.6.0 → 0.6.1

data/lib/gecoder/interface/constraints.rb

@@ -196,15 +196,19 @@ module Gecode
     class CompositeExpression < Gecode::Constraints::Expression
       # The expression class should be the class of the expression delegated to,
       # the variable class the kind of single variable used in the expression.
-      # The block given should take three parameters. The first is the variable 
-      # that should be the left hand side, if it's nil then a new one should be
-      # created. The second is the has of parameters. The block should return 
-      # the variable used as left hand side.
-      def initialize(expression_class, variable_class, model, params, &block)
+      # The new var proc should produce a new variable (of the appropriate type)
+      # which has an unconstricted domain. The block given should take three 
+      # parameters. The first is the variable that should be the left hand side.
+      # The second is the hash of parameters. The third is a boolean, it it's 
+      # true then the block should try to constrain the first variable's domain 
+      # as much as possible. 
+      def initialize(expression_class, variable_class, new_var_proc, model, 
+          params, &block)
         super(model, params)
         @expression_class = expression_class
         @variable_class = variable_class
-        @proc = block
+        @new_var_proc = new_var_proc
+        @constrain_equal_proc = block
       end
       
       # Delegate to an instance of the expression class when we get something 
@@ -215,9 +219,17 @@ module Gecode
           if args.size >= 2 and args[1].kind_of? Hash
             options = args[1]
           end
+          
+          # Link a variable to the composite constraint.
           @params.update Gecode::Constraints::Util.decode_options(options.clone)
-          @params[:lhs] = @proc.call(nil, @params)
-          @expression_class.new(@model, @params).send(name, *args)
+          variable = @new_var_proc.call
+          @model.add_interaction do
+            @constrain_equal_proc.call(variable, @params, true)
+          end
+          
+          # Perform the operation on the linked variable.
+          int_var_params = @params.clone.update(:lhs => variable)
+          @expression_class.new(@model, int_var_params).send(name, *args)
         else
           super
         end
@@ -228,7 +240,9 @@ module Gecode
             expression.kind_of? @variable_class
           # We don't need any additional constraints.
           @params.update Gecode::Constraints::Util.decode_options(options)
-          @proc.call(expression, @params)
+          @model.add_interaction do
+            @constrain_equal_proc.call(expression, @params, false)
+          end
         else
           method_missing(:==, expression, options)
         end
@@ -299,18 +313,17 @@ module Gecode
       private
       
       # Constrains the result of the stub to be equal to the specified variable
-      # with the specified parameters. If the variable given is nil then a new
-      # variable should be created for the purpose and returned. This is an 
-      # abstract method and should be overridden by all sub-classes.
-      def constrain_equal(variable, params)
+      # with the specified parameters. If constrain is true then the variable's
+      # domain should additionally be constrained as much as possible.
+      def constrain_equal(variable, params, constrain)
         raise NoMethodError, 'Abstract method has not been implemented.'
       end
       
       # Produces an expression with position for the lhs module.
       def expression(params)
         @params.update params
-        @composite_class.new(@model, @params) do |var, params|
-          constrain_equal(var, params)
+        @composite_class.new(@model, @params) do |var, params, constrain|
+          constrain_equal(var, params, constrain)
         end
       end
     end

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

@@ -19,11 +19,8 @@ module Gecode
     # Describes an expression stub started with a bool var enum following by 
     # #conjunction.
     class ConjunctionStub < Gecode::Constraints::Bool::CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         enum, strength = @params.values_at(:lhs, :strength)
-        if variable.nil?
-          variable = @model.bool_var
-        end
         
         @model.add_interaction do
           if variable.respond_to? :bind
@@ -41,22 +38,16 @@ module Gecode
     # Describes an expression stub started with a bool var enum following by 
     # #disjunction.
     class DisjunctionStub < Gecode::Constraints::Bool::CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         enum, strength = @params.values_at(:lhs, :strength)
-        if variable.nil?
-          variable = @model.bool_var
-        end
         
-        @model.add_interaction do
-          if variable.respond_to? :bind
-            bound = variable.bind
-          else
-            bound = variable
-          end
-          Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
-            bound, strength)
+        if variable.respond_to? :bind
+          bound = variable.bind
+        else
+          bound = variable
         end
-        return variable
+        Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
+          bound, strength)
       end
     end
   end

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

@@ -26,21 +26,26 @@ module Gecode
       # created. The second is the has of parameters. The block should return 
       # the variable used as left hand side.
       def initialize(model, params, &block)
-        super(Expression, Gecode::FreeIntVar, model, params, &block)
+        super(Expression, Gecode::FreeBoolVar, lambda{ model.bool_var }, model,
+          params, &block)
       end
       
       # Override to also deal with constant booleans.
       def true(options = {})
         # We don't need any additional constraints.
         @params.update Gecode::Constraints::Util.decode_options(options)
-        @proc.call(!@params[:negate], @params)
+        @model.add_interaction do
+          @constrain_equal_proc.call(!@params[:negate], @params)
+        end
       end
       
       # Override to also deal with constant booleans.
       def false(options = {})
         # We don't need any additional constraints.
         @params.update Gecode::Constraints::Util.decode_options(options)
-        @proc.call(@params[:negate], @params)
+        @model.add_interaction do
+          @constrain_equal_proc.call(@params[:negate], @params)
+        end
       end
     end
     

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

@@ -23,36 +23,31 @@ module Gecode::Constraints::Int::Arithmetic
   # Describes an expression stub started with an integer variable followed by 
   # #abs .
   class AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params)
+    def constrain_equal(variable, params, constrain)
       lhs, strength = @params.values_at(:lhs, :strength)
-      if variable.nil?
-        variable = @model.int_var(lhs.min..lhs.max)
+      if constrain
+        bounds = [lhs.min.abs, lhs.max.abs]
+        variable.must_be.in bounds.min..bounds.max
       end
       
-      @model.add_interaction do
-        Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
-      end
-      return variable
+      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
     end
   end
   
   # Describes an expression stub started with an integer variable followed by 
   # #* .
   class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params)
+    def constrain_equal(variable, params, constrain)
       lhs, lhs2, strength = @params.values_at(:lhs, :var, :strength)
-      if variable.nil?
+      if constrain
         a_min = lhs.min; a_max = lhs.max
         b_min = lhs2.min; b_max = lhs2.max
         products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
-        variable = @model.int_var(products.min..products.max)
+        variable.must_be.in products.min..products.max
       end
 
-      @model.add_interaction do
-        Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
-          variable.bind, strength)
-      end
-      return variable
+      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
+        variable.bind, strength)
     end
   end
 end

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

@@ -18,33 +18,27 @@ end
 module Gecode::Constraints::IntEnum::Arithmetic 
   # Describes an expression stub started with an int var enum following by #max.
   class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params)
+    def constrain_equal(variable, params, constrain)
       enum, strength = @params.values_at(:lhs, :strength)
-      if variable.nil?
-        variable = @model.int_var(enum.domain_range)
+      if constrain
+        variable.must_be.in enum.domain_range
       end
       
-      @model.add_interaction do
-        Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
-          variable.bind, strength)
-      end
-      return variable
+      Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
     end
   end
   
   # Describes an expression stub started with an int var enum following by #min.
   class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params)
+    def constrain_equal(variable, params, constrain)
       enum, strength = @params.values_at(:lhs, :strength)
-      if variable.nil?
-        variable = @model.int_var(enum.domain_range)
+      if constrain
+        variable.must_be.in enum.domain_range
       end
       
-      @model.add_interaction do
-        Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
-          variable.bind, strength)
-      end
-      return variable
+      Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
     end
   end
 end

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

@@ -3,19 +3,14 @@ module Gecode::Constraints::IntEnum::Element
   # Describes an expression stub started with an int var enum following with an 
   # array access using an integer variables .
   class ExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params)
+    def constrain_equal(variable, params, constrain)
       enum, position, strength = @params.values_at(:lhs, :position, :strength)
-      if variable.nil?
-        variable = @model.int_var(enum.domain_range)
-      end
+      variable.must_be.in enum.domain_range
 
-      @model.add_interaction do
-        # 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)
-      end
-      return variable
+      # 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)
     end
   end
   

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

@@ -25,7 +25,8 @@ module Gecode
       # created. The second is the has of parameters. The block should return 
       # the variable used as left hand side.
       def initialize(model, params, &block)
-        super(Expression, Gecode::FreeIntVar, model, params, &block)
+        super(Expression, Gecode::FreeIntVar, lambda{ model.int_var }, model, 
+          params, &block)
       end
     end
     

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

@@ -43,16 +43,13 @@ module Gecode::Constraints::Set
     # Describes an expression stub started with a set variable followed by 
     # #size .
     class SizeExpressionStub < CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         lhs = @params[:lhs]
-        if variable.nil?
-          variable = @model.int_var(lhs.lower_bound.size, lhs.upper_bound.size)
+        if constrain
+          variable.must_be.in lhs.lower_bound.size..lhs.upper_bound.size
         end
         
-        @model.add_interaction do 
-          Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
-        end
-        return variable
+        Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
       end
     end
   end

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

@@ -71,55 +71,46 @@ module Gecode::Constraints::Set
   module Connection
     # Describes an expression stub started with an int var following by #min.
     class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         set = params[:lhs]
-        if variable.nil?
-          variable = @model.int_var(set.upper_bound.min, set.lower_bound.min)
+        if constrain
+          variable.must_be.in set.upper_bound.min..set.lower_bound.min
         end
         
-        @model.add_interaction do
-          Gecode::Raw::min(@model.active_space, set.bind, variable.bind)
-        end
-        return variable
+        Gecode::Raw::min(@model.active_space, set.bind, variable.bind)
       end
     end
     
     # Describes an expression stub started with an int var following by #max.
     class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         set = params[:lhs]
-        if variable.nil?
-          variable = @model.int_var(set.upper_bound.max, set.lower_bound.max)
+        if constrain
+          variable.must_be.in set.lower_bound.max..set.upper_bound.max
         end
         
-        @model.add_interaction do
-          Gecode::Raw::max(@model.active_space, set.bind, variable.bind)
-        end
-        return variable
+        Gecode::Raw::max(@model.active_space, set.bind, variable.bind)
       end
     end
     
     # Describes an expression stub started with an int var following by #max.
     class SumExpressionStub < Gecode::Constraints::Int::CompositeStub
-      def constrain_equal(variable, params)
+      def constrain_equal(variable, params, constrain)
         set, subs = params.values_at(:lhs, :substitutions)
         lub = set.upper_bound.to_a
         lub.delete_if{ |e| subs[e].nil? }
         substituted_lub = lub.map{ |e| subs[e] }
-        if variable.nil?
+        if constrain
           # Compute the theoretical bounds of the weighted sum. This is slightly
           # sloppy since we could also use the contents of the greatest lower 
           # bound.
           min = substituted_lub.find_all{ |e| e < 0}.inject(0){ |x, y| x + y }
           max = substituted_lub.find_all{ |e| e > 0}.inject(0){ |x, y| x + y }
-          variable = @model.int_var(min..max)
+          variable.must_be.in min..max
         end
 
-        @model.add_interaction do
-          Gecode::Raw::weights(@model.active_space, lub, substituted_lub, 
-            set.bind, variable.bind)
-        end
-        return variable
+        Gecode::Raw::weights(@model.active_space, lub, substituted_lub, 
+          set.bind, variable.bind)
       end
     end
     

data/lib/gecoder/interface/model.rb

@@ -2,22 +2,22 @@ module Gecode
   # Model is the base class that all models must inherit from.
   class Model
     # Creates a new integer variable with the specified domain. The domain can
-    # either be a range or a number of elements. 
-    def int_var(*domain_args)
-      enum = domain_enum(*domain_args)
-      index = selected_space.new_int_vars(enum).first
+    # 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)
+      enum = domain_enum(domain)
+      index = variable_creation_space.new_int_vars(enum).first
       FreeIntVar.new(self, index)
     end
     
     # Creates an array containing the specified number of integer variables 
-    # with the specified domain. The domain can either be a range or a number 
-    # of elements. 
-    def int_var_array(count, *domain_args)
-      # TODO: Maybe the custom domain should be specified as an array instead? 
-      
-      enum = domain_enum(*domain_args)
+    # 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 = []
-      selected_space.new_int_vars(enum, count).each do |index|
+      variable_creation_space.new_int_vars(enum, count).each do |index|
         variables << FreeIntVar.new(self, index)
       end
       return wrap_enum(variables)
@@ -25,12 +25,10 @@ module Gecode
     
     # Creates a matrix containing the specified number rows and columns of 
     # integer variables with the specified domain. The domain can either be a 
-    # range or a number of elements. 
-    def int_var_matrix(row_count, col_count, *domain_args)
-      # TODO: Maybe the custom domain should be specified as an array instead? 
-      
-      enum = domain_enum(*domain_args)
-      indices = selected_space.new_int_vars(enum, row_count*col_count)
+    # 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|
@@ -41,15 +39,15 @@ module Gecode
     end
     
     # Creates a new boolean variable.
-    def bool_var(*domain_args)
-      index = selected_space.new_bool_vars.first
+    def bool_var
+      index = variable_creation_space.new_bool_vars.first
       FreeBoolVar.new(self, index)
     end
     
     # Creates an array containing the specified number of boolean variables.
     def bool_var_array(count)
       variables = []
-      selected_space.new_bool_vars(count).each do |index|
+      variable_creation_space.new_bool_vars(count).each do |index|
         variables << FreeBoolVar.new(self, index)
       end
       return wrap_enum(variables)
@@ -58,7 +56,7 @@ module Gecode
     # Creates a matrix containing the specified number rows and columns of 
     # boolean variables.
     def bool_var_matrix(row_count, col_count)
-      indices = selected_space.new_bool_vars(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|
@@ -77,7 +75,7 @@ module Gecode
     def set_var(glb_domain, lub_domain, cardinality_range = nil)
       check_set_bounds(glb_domain, lub_domain)
       
-      index = selected_space.new_set_vars(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)
     end
@@ -88,7 +86,7 @@ module Gecode
       check_set_bounds(glb_domain, lub_domain)
       
       variables = []
-      selected_space.new_set_vars(glb_domain, lub_domain, 
+      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)
       end
@@ -102,7 +100,7 @@ module Gecode
         cardinality_range = nil)
       check_set_bounds(glb_domain, lub_domain)
       
-      indices = selected_space.new_set_vars(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|
@@ -159,6 +157,12 @@ module Gecode
       return res
     end
     
+    # Starts tracking a variable that depends on the space. All variables 
+    # created should call this method for their respective models.
+    def track_variable(variable)
+      (@variables ||= []) << variable
+    end
+    
     protected
     
     # Gets a queue of objects that can be posted to the model's active_space 
@@ -170,25 +174,19 @@ module Gecode
     private
     
     # Returns an enumeration of the specified domain arguments, which can 
-    # either be given as a range or a number of elements. Raises ArgumentError 
-    # if no arguments have been specified. 
-    def domain_enum(*domain_args)
-      if domain_args.empty?
-        raise ArgumentError, 'A domain has to be specified.'
-      elsif domain_args.size > 1
-        return domain_args
-      else
-        element = domain_args.first
-        if element.respond_to?(:first) and element.respond_to?(:last) and
-            element.respond_to?(:exclude_end?)
-          if element.exclude_end?
-            return element.first..(element.last - 1)
-          else
-            return element
-          end
+    # either be given as a range, a single number, or an enumerable of elements. 
+    def domain_enum(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)
         else
-          return element..element
+          return domain
         end
+      elsif domain.kind_of? Enumerable
+        return domain
+      else
+        return domain..domain
       end
     end
     
@@ -232,5 +230,18 @@ module Gecode
     def selected_space
       @active_space ||= base_space
     end
+    
+    # Retrieves the space that should be used for variable creation.
+    def variable_creation_space
+      @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
+      @variables.each do |variable|
+        variable.refresh if variable.cached?
+      end
+    end
   end
 end