gecoder-with-gecode 0.8.2 → 0.8.3

data/lib/gecoder/interface/binding_changes.rb

@@ -1,309 +1,9 @@
-# This file adds a small layer on top of the bindings. It alters the allocation 
-# of variables so that a single array is allocated in each space which is then 
-# used to store variable. The variables themselves are not directly returned, 
-# rather they are represented as the index in that store, which allows the 
-# variable to be retrieved back given a space.
-#
-# This layer should be moved to the C++ side instead when possible for better
-# performance.
+# This file adds a small layer on top of the bindings.
 module GecodeRaw #:nodoc: all
   class Space
-    # Creates the specified number of integer variables in the space with the
-    # specified domain. Returns the indices with which they can then be 
-    # accessed using int_var. The domain can be given as a Range (trated 
-    # specially) or as another enum.
-    def new_int_vars(domain, count = 1)
-      int_var_store.new_vars(domain, count)
-    end
-    
-    # Gets the int variable with the specified index, nil if none exists.
-    def int_var(index)
-      int_var_store[index]
-    end
-    
-    # Creates the specified number of boolean variables in the space. Returns
-    # the indices with which they can then be accessed using bool_var.
-    def new_bool_vars(count = 1)
-      bool_var_store.new_vars(count)
-    end
-    
-    # Gets the bool variable with the specified index, nil if none exists.
-    def bool_var(index)
-      bool_var_store[index]
-    end
-    
-    # Creates the specified number of set variables in the space with the 
-    # specified domain for greatest lower bound and least upper bound 
-    # (specified as either a range or enum). 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. Returns 
-    # the indices with which they can then be accessed using set_var.
-    def new_set_vars(*vars)
-      set_var_store.new_vars(*vars)
-    end
-    
-    # Gets the set variable with the specified index, nil if none exists.
-    def set_var(index)
-      set_var_store[index]
-    end
-    
     # Used by Gecode during BAB-search.
     def constrain(best_so_far_space)
       Gecode::Model.constrain(self, best_so_far_space)
     end
-    
-    # Refreshes the underlying stores used by the space.
-    def refresh
-      @int_var_store = nil
-      @bool_var_store = nil
-      @set_var_store = nil
-    end
-    
-    private
-    
-    # Retrieves the store used for integer variables. Creates one if none
-    # exists.
-    def int_var_store
-      # TODO: caching interferes with the variable creation during BAB-search,
-      # find out why.
-      #if @int_var_store.nil?
-        @int_var_store = Gecode::Util::IntVarStore.new(self) 
-      #end
-      return @int_var_store
-    end
-    
-    # Retrieves the store used for boolean variables. Creates one if none
-    # exists.
-    def bool_var_store
-      #if @bool_var_store.nil?
-        @bool_var_store = Gecode::Util::BoolVarStore.new(self) 
-      #end
-      return @bool_var_store
-    end
-    
-    # Retrieves the store used for set variables. Creates one if none exists.
-    def set_var_store
-      #if @set_var_store.nil?
-        @set_var_store = Gecode::Util::SetVarStore.new(self) 
-      #end
-      return @set_var_store
-    end
-  end
-end
-
-module Gecode
-  # Various utility (mainly used to change the behavior of the raw bindings).
-  module Util #:nodoc: all
-    # Provides common methods to the variable stores. The stores must provide
-    # @next_index, @var_array, @size, ARRAY_IDENTIFIER and #new_storage_array .
-    module VarStoreMethods
-      # Returns the int var with the specified index, nil if none exists.
-      def [](index)
-        if index < 0 or index >= @next_index
-          return nil
-        end
-        return @var_array.at(index)
-      end
-      
-      private
-      
-      # Grows the store to the new size.
-      def grow(new_size)
-        @var_array.enlargeArray(@space, new_size - @size)
-        @size = new_size
-      end
-    end
-  
-    # A store in which int variables are created and stored.
-    class IntVarStore
-      # Design note: The store used to double its size when it needed to grow
-      # leaving unallocated slots (in rev 16). This was changed to only growing
-      # the amount of space needed because the additional information about which
-      # slot is the next unallocated one could not be encoded without changes to
-      # the bindings (and without that information we can not deduce the store
-      # from the new copy of space). So for additional performance the bindings 
-      # should grow the array more than needed (when this is moved to the bindings).
-      
-      include VarStoreMethods
-      
-      private
-    
-      # A string that identifies the array used by the store.
-      ARRAY_IDENTIFIER = 'int_array'
-    
-      public
-      
-      # Creates a store for the specified space with the specified capacit.
-      def initialize(space)
-        @space = space
-        
-        @var_array = space.int_var_array(ARRAY_IDENTIFIER)
-        if @var_array.nil?
-          # Create a new one.
-          @var_array = new_storage_array(0)
-        end
-  
-        @size = @var_array.size
-        @next_index = @size
-      end
-      
-      # Creates the specified number of integer variables in the space with the
-      # specified domain. Returns the indices with which they can then be 
-      # accessed using int_var. The domain can be given as a Range (trated 
-      # specially) or as another enum.
-      def new_vars(domain, count = 1)
-        grow(@next_index + count) # See the design note for more information.
-        count.times do |i|
-          if domain.kind_of? Range
-            domain_params = [domain.first, domain.last] 
-          elsif domain.kind_of? Enumerable
-            arr = domain.to_a
-            domain_params = [Gecode::Raw::IntSet.new(arr, arr.size)]
-          else
-            raise TypeError, "Expected Enumerable, got #{domain.class}."
-          end
-
-          @var_array[@next_index] = Gecode::Raw::IntVar.new(@space, 
-            *domain_params)
-          @next_index += 1
-        end
-        
-        ((@next_index - count)...@next_index).to_a
-      end
-  
-      # Returns the int var with the specified index, nil if none exists.
-      def [](index)
-        if index < 0 or index >= @next_index
-          return nil
-        end
-        return @var_array.at(index)
-      end
-  
-      private
-      
-      # Creates a new storage array for int variables.
-      def new_storage_array(new_size)
-        arr = Gecode::Raw::IntVarArray.new(@space, new_size)
-        @space.own(arr, ARRAY_IDENTIFIER)
-        return arr
-      end
-    end
-    
-    # A store in which int variables are created and stored.
-    class BoolVarStore
-      # TODO: can we refactor this better seeing as IntVarStore and BoolVarStore
-      # are similar?
-      
-      include VarStoreMethods
-      
-      private
-    
-      # A string that identifies the array used by the store.
-      ARRAY_IDENTIFIER = 'bool_array'
-    
-      public
-      
-      # Creates a store for the specified space with the specified capacit.
-      def initialize(space)
-        @space = space
-      
-        @var_array = space.bool_var_array(ARRAY_IDENTIFIER)
-        if @var_array.nil?
-          # Create a new one.
-          @var_array = new_storage_array(0)
-        end
-  
-        @size = @var_array.size
-        @next_index = @size
-      end
-      
-      # Creates the specified number of new bool variables. Returns the indices 
-      # of the created variables as an array.
-      def new_vars(count = 1)
-        grow(@next_index + count) # See the design note for more information.
-        count.times do |i|
-          @var_array[@next_index] = Gecode::Raw::BoolVar.new(@space, 0, 1)
-          @next_index += 1
-        end
-        
-        ((@next_index - count)...@next_index).to_a
-      end
-  
-      private
-      
-      # Creates a new storage array for bool variables.
-      def new_storage_array(new_size)
-        arr = Gecode::Raw::BoolVarArray.new(@space, new_size)
-        @space.own(arr, ARRAY_IDENTIFIER)
-        return arr
-      end
-    end
-    
-    # A store in which int variables are created and stored.
-    class SetVarStore
-      include VarStoreMethods
-      
-      private
-    
-      # A string that identifies the array used by the store.
-      ARRAY_IDENTIFIER = 'set_array'
-    
-      public
-      
-      # Creates a store for the specified space with the specified capacit.
-      def initialize(space)
-        @space = space
-      
-        @var_array = space.set_var_array(ARRAY_IDENTIFIER)
-        if @var_array.nil?
-          # Create a new one.
-          @var_array = new_storage_array(0)
-        end
-  
-        @size = @var_array.size
-        @next_index = @size
-      end
-      
-      # Creates the specified number of set variables in the space with the 
-      # specified domain for greatest lower bound and least upper bound 
-      # (specified as either a range or enum). 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. Returns 
-      # the indices with which they can then be accessed using set_var.
-      def new_vars(glb_domain, lub_domain, cardinality_range = nil, count = 1)
-        grow(@next_index + count) # See the design note for more information.
-
-        if cardinality_range.nil?
-          cardinality_range = 0..Gecode::Raw::SetLimits::CARD
-        end
-        
-        params = [@space]
-        params << domain_to_args(glb_domain)
-        params << domain_to_args(lub_domain)
-        params << cardinality_range.first << cardinality_range.last
-        count.times do |i|
-          @var_array[@next_index] = Gecode::Raw::SetVar.new(*params.flatten)
-          @next_index += 1
-        end
-        
-        ((@next_index - count)...@next_index).to_a
-      end
-  
-      private
-      
-      # Transforms a lub or glb domain given as a fixnum, range or enumeration 
-      # into one or more parameters that describe the domain to 
-      # Gecode::Raw::SetVar .
-      def domain_to_args(domain)
-        Gecode::Constraints::Util.constant_set_to_int_set(domain)
-      end
-      
-      # Creates a new storage array for bool variables.
-      def new_storage_array(new_size)
-        arr = Gecode::Raw::SetVarArray.new(@space, new_size)
-        @space.own(arr, ARRAY_IDENTIFIER)
-        return arr
-      end
-    end
   end
 end

data/lib/gecoder/interface/branch.rb

@@ -1,13 +1,14 @@
 module Gecode
   class Model
-    # Specifies which variables that should be branched on. One can optionally
-    # also select which of the variables that should be used first with the
-    # :variable option and which value in that variable's domain that should be 
-    # used with the :value option. If nothing is specified then :variable uses
-    # :none and value uses :min.
+    # Specifies which variables that should be branched on (given as an
+    # enum of variables or as a single variable). One can optionally
+    # also select which of the variables that should be used first with
+    # the :variable option and which value in that variable's domain
+    # that should be used with the :value option. If nothing is
+    # specified then :variable uses :none and value uses :min.
     #
-    # The following values can be used with :variable for integer and boolean 
-    # enums:
+    # The following values can be used with :variable for integer and
+    # boolean enums:
     # [:none]                 The first unassigned variable.
     # [:smallest_min]         The one with the smallest minimum.
     # [:largest_min]          The one with the largest minimum.
@@ -58,10 +59,13 @@ module Gecode
     #                         elements
     #
     # The following values can be used with :value set enums: 
-    # enums:
     # [:min]        Selects the smallest value in the unknown part of the set.
     # [:max]        Selects the largest value in the unknown part of the set.
     def branch_on(variables, options = {})
+      if variables.respond_to? :bind
+        variables = wrap_enum [variables]
+      end
+
       if variables.respond_to? :to_int_var_array or 
           variables.respond_to? :to_bool_var_array
         add_branch(variables, options, Constants::BRANCH_INT_VAR_CONSTANTS, 
@@ -78,8 +82,8 @@ module Gecode
     
     # This is a hack to get RDoc to ignore the constants.
     module Constants #:nodoc:
-      # Maps the names of the supported variable branch strategies for integer and
-      # booleans to the corresponding constant in 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::INT_VAR_NONE,
         :smallest_min         => Gecode::Raw::INT_VAR_MIN_MIN,
@@ -149,4 +153,4 @@ module Gecode
       end
     end
   end
-end
+end

data/lib/gecoder/interface/constraints.rb

@@ -271,6 +271,43 @@ module Gecode
       
       private
       
+      # Provides commutivity for the constraint with the specified method name.
+      # If the method with the specified method name is called with something 
+      # that, when given to the block, evaluates to true, then the constraint
+      # will be called on the right hand side with the left hand side as 
+      # argument.
+      #
+      # The original constraint method is assumed to take two arguments: a 
+      # right hand side and a hash of options.
+      def self.provide_commutivity(constraint_name, &block)
+        unique_id = constraint_name.to_sym.to_i
+        pre_alias_method_name = 'pre_commutivity_' << unique_id.to_s
+        if method_defined? constraint_name
+          alias_method pre_alias_method_name, constraint_name
+        end
+        
+        module_eval <<-end_code
+          @@commutivity_check_#{unique_id} = block
+          def #{constraint_name}(rhs, options = {})
+            if @@commutivity_check_#{unique_id}.call(rhs, options)
+              if @params[:negate]
+                rhs.must_not.method(:#{constraint_name}).call(
+                  @params[:lhs], options)
+              else
+                rhs.must.method(:#{constraint_name}).call(
+                  @params[:lhs], options)
+              end
+            else
+              if self.class.method_defined? :#{pre_alias_method_name}
+                #{pre_alias_method_name}(rhs, options)
+              else
+                raise TypeError, \"Unexpected argument type \#{rhs.class}.\" 
+              end
+            end
+          end
+        end_code
+      end
+      
       # Creates aliases for any defined comparison methods.
       def self.alias_comparison_methods
         Gecode::Constraints::Util::COMPARISON_ALIASES.each_pair do |orig, aliases|
@@ -472,3 +509,4 @@ require 'gecoder/interface/constraints/bool_var_constraints'
 require 'gecoder/interface/constraints/bool_enum_constraints'
 require 'gecoder/interface/constraints/set_var_constraints'
 require 'gecoder/interface/constraints/set_enum_constraints'
+require 'gecoder/interface/constraints/extensional_regexp'

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

@@ -26,16 +26,15 @@ module Gecode
     # Describes a boolean expression (following after must*).
     class Expression #:nodoc:
       def ==(expression, options = {})
-        unless expression.kind_of?(ExpressionTree) or 
-            expression.kind_of?(Gecode::FreeBoolVar) or 
-            expression.kind_of?(TrueClass) or expression.kind_of?(FalseClass) or
-            expression.respond_to?(:to_minimodel_lin_exp)
-          raise TypeError, 'Invalid right hand side of boolean equation.'
+        if expression.kind_of? Gecode::Constraints::Int::Linear::ExpressionTree
+          return expression.must == @params[:lhs]
+        end
+        unless expression.respond_to? :to_minimodel_bool_expr
+          expression = Constraints::Bool::ExpressionNode.new(expression, @model)
         end
-        
         @params.update Gecode::Constraints::Util.decode_options(options)
-        @model.add_constraint BooleanConstraint.new(@model, 
-          @params.update(:rhs => expression))
+        @params.update(:lhs => @params[:lhs], :rhs => expression)
+        @model.add_constraint BooleanConstraint.new(@model, @params)
       end
       alias_comparison_methods
       
@@ -47,14 +46,14 @@ module Gecode
       end
       
       # Constrains the boolean expression to be true.
-      def true
-        @params.update Gecode::Constraints::Util.decode_options({})
+      def true(options = {})
+        @params.update Gecode::Constraints::Util.decode_options(options)
         @model.add_constraint BooleanConstraint.new(@model, 
           @params.update(:rhs => true))
       end
       
       # Constrains the boolean expression to be false.
-      def false
+      def false(options = {})
         @params[:negate] = !@params[:negate]
         self.true
       end
@@ -136,32 +135,37 @@ module Gecode
         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 
-        # variables and constraints a bit by altering the way that the top node
-        # is posted, using its constraint for reification etc when possible. 
-        
-        if rhs.respond_to? :bind
+
+        if lhs.kind_of?(Gecode::FreeBoolVar)
+          lhs = Constraints::Bool::ExpressionNode.new(lhs, @model)
+        end
+
+        bot_eqv = Gecode::Raw::IRT_EQ
+        bot_xor = Gecode::Raw::IRT_NQ
+
+        if rhs.respond_to? :to_minimodel_bool_expr
           if reif_var.nil?
-            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
-              (!negate ? 1 : 0), *propagation_options)
+            tree = ExpressionTree.new(lhs, 
+              Gecode::Raw::MiniModel::BoolExpr::NT_EQV, rhs)
+            tree.to_minimodel_bool_expr.post(space, !negate, 
+              *propagation_options)
           else
-            if negate
-              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_XOR, rhs.bind, 
-                reif_var.bind, *propagation_options)
-            else
-              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
-                reif_var.bind, *propagation_options)
-            end
+            tree = ExpressionTree.new(lhs, 
+              Gecode::Raw::MiniModel::BoolExpr::NT_EQV, rhs)
+            var = tree.to_minimodel_bool_expr.post(space, *propagation_options)
+            Gecode::Raw::rel(space, var, (negate ? bot_xor : bot_eqv),
+              reif_var.bind, *propagation_options)
           end
         else
           should_hold = !negate & rhs
           if reif_var.nil?
-            Gecode::Raw::MiniModel::BoolExpr.new(lhs.bind).post(space, 
-              should_hold, *propagation_options)
+            lhs.to_minimodel_bool_expr.post(space, should_hold, 
+              *propagation_options)
           else
-            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, 
-              reif_var.bind, (should_hold ? 1 : 0), *propagation_options)
+            var = lhs.to_minimodel_bool_expr.post(space, *propagation_options)
+            Gecode::Raw::rel(space, var, 
+              (should_hold ? bot_eqv : bot_xor),
+              reif_var.bind, *propagation_options)
           end
         end
       end
@@ -177,10 +181,10 @@ module Gecode
       # Maps the names of the methods to the corresponding bool constraint in 
       # Gecode.
       OPERATION_TYPES = {
-        :|        => Gecode::Raw::BOT_OR,
-        :&        => Gecode::Raw::BOT_AND,
-        :^        => Gecode::Raw::BOT_XOR,
-        :implies  => Gecode::Raw::BOT_IMP
+        :|        => Gecode::Raw::MiniModel::BoolExpr::NT_OR,
+        :&        => Gecode::Raw::MiniModel::BoolExpr::NT_AND,
+        :^        => Gecode::Raw::MiniModel::BoolExpr::NT_XOR,
+        :implies  => Gecode::Raw::MiniModel::BoolExpr::NT_IMP
       }
       
       public
@@ -191,13 +195,7 @@ module Gecode
             unless expression.kind_of? ExpressionTree
               expression = ExpressionNode.new(expression)
             end
-            ExpressionTree.new(self, expression) do |model, var1, var2|
-              new_var = model.bool_var
-              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
+            ExpressionTree.new(self, #{operation}, expression)
           end
         end_code
       end
@@ -216,17 +214,19 @@ module Gecode
     class ExpressionTree #:nodoc:
       include OperationMethods
     
-      # Constructs a new expression with the specified nodes. The proc should 
-      # take a model followed by two variables and return a new variable.
-      def initialize(left_tree, right_tree, &block)
+      # Constructs a new expression with the specified binary operation 
+      # applied to the specified trees.
+      def initialize(left_tree, operation, right_tree)
         @left = left_tree
+        @operation = operation
         @right = right_tree
-        @bind_proc = block
       end
       
-      # Returns a bound boolean variable representing the expression. 
-      def bind
-        @bind_proc.call(model, @left, @right).bind
+      # Returns a MiniModel boolean expression representing the tree.
+      def to_minimodel_bool_expr
+        Gecode::Raw::MiniModel::BoolExpr.new(
+          @left.to_minimodel_bool_expr, @operation, 
+          @right.to_minimodel_bool_expr)
       end
       
       # Fetches the space that the expression's variables is in.
@@ -242,14 +242,18 @@ module Gecode
       attr :model
     
       def initialize(value, model = nil)
+        unless value.kind_of?(Gecode::FreeBoolVar)
+          raise TypeError, 'Invalid type used in boolean equation: ' +
+            "#{value.class}."
+        end
         @value = value
         @model = model
       end
       
-      # Returns a bound boolean variable representing the expression. 
-      def bind
-        @value.bind
+      # Returns a MiniModel boolean expression representing the tree.
+      def to_minimodel_bool_expr
+        Gecode::Raw::MiniModel::BoolExpr.new(@value.bind)
       end
     end
   end
-end
+end