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

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

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

@@ -1,23 +1,8 @@
 module Gecode::Constraints::Bool
   class Expression
-    alias_method :pre_channel_equals, :==
-    
     # Constrains the boolean variable to be equal to the specified integer 
     # variable.
-    def ==(int, options = {})
-      unless @params[:lhs].kind_of?(Gecode::FreeBoolVar) and 
-          int.kind_of?(Gecode::FreeIntVar)
-        return pre_channel_equals(int, options)
-      end
-      
-      # Provide commutivity to the corresponding int variable constraint.
-      if @params[:negate]
-        int.must_not.equal(@params[:lhs], options)
-      else
-        int.must.equal(@params[:lhs], options)
-      end
-    end
-    
+    provide_commutivity(:==){ |rhs, _| rhs.kind_of?(Gecode::FreeIntVar) }
     alias_comparison_methods
   end
 end

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

@@ -6,7 +6,7 @@ module Gecode::Constraints::BoolEnum
     #
     # [:offset]  Specifies an offset for the integer variable. If the offset is
     #            set to k then the integer variable takes value i+k exactly 
-    #            when the variable at index i in the boolean enumration is true 
+    #            when the variable at index i in the boolean enumeration is true 
     #            and the rest are false.
     def channel(int_var, options = {})
       if @params[:negate]
@@ -25,28 +25,33 @@ module Gecode::Constraints::BoolEnum
       @params.update(Gecode::Constraints::Util.decode_options(options))
       @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
     end
+
+    # Adds a channel constraint on the variables in the enum with the specified 
+    # set variable.
+    provide_commutivity(:channel){ |rhs, _| rhs.kind_of? Gecode::FreeSetVar }
   end
   
   # A module that gathers the classes and modules used in channel constraints
   # involving one boolean enum and one integer variable.
   module Channel #:nodoc:
-    # Describes a channel constraint that "channels" an enumerations of 
+    # Describes a channel constraint that "channels" an enumeration of 
     # boolean variables with an integer variable. This constrains the integer
     # variable to take value i exactly when the variable at index i in the 
     # boolean enumeration is true and the others are false.
     # 
-    # Neither reification nor negation is supported.
+    # Neither reification nor negation is supported. The int variable
+    # and the enumeration can be interchanged.
     #
     # == Examples
     #
-    # # Constrains the enumeration called +selected_option+ to be false in the
+    # # Constrains the enumeration called +option_is_selected+ to be false in the
     # # first four positions and have exactly one true variable in the other. 
-    # selected_option.must.channel selected_option_index 
+    # option_is_selected.must.channel selected_option_index 
     # selected_option_index.must_be > 3
     #
-    # # Constrains the enumeration called +selected_option+ to be false in the
+    # # Constrains the enumeration called +option_is_selected+ to be false in the
     # # first five positions and have exactly one true variable in the other. 
-    # selected_option.must.channel(selected_option_index, :offset => 1) 
+    # selected_option_index.must.channel(option_is_selected, :offset => 1) 
     # selected_option_index.must_be > 3
     class ChannelConstraint < Gecode::Constraints::Constraint
       def post
@@ -56,4 +61,4 @@ module Gecode::Constraints::BoolEnum
       end
     end
   end
-end
+end

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

@@ -25,6 +25,27 @@ module Gecode::Constraints::BoolEnum
       @model.add_constraint Extensional::TupleConstraint.new(@model, 
         @params.update(Gecode::Constraints::Util.decode_options(options)))
     end
+
+    # Adds a constraint that forces the enumeration to match the
+    # specified regular expression over the boolean domain. The regular
+    # expression is expressed using arrays and boolean values (or
+    # integers). See BoolEnum::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,32 @@ module Gecode::Constraints::BoolEnum
           *propagation_options)
       end
     end
+
+    # Describes a regexp constraint, which constrains the enumeration of
+    # boolean variables to match a specified regexp in the boolean
+    # domain. Neither negation nor reification is supported.
+    #
+    # The regular expressions are specified as described in
+    # IntEnum::Extensional::RegexpConstraint but true and false can be
+    # used instead of integers.
+    #
+    # == Example
+    #
+    #   # Constrains the two boolean variables in +bools+ to be false
+    #   # and true respectively.
+    #   bools.must.match [false, true]
+    #
+    #   # Constrains the boolean variables in +bools+ to be false,
+    #   # except for three consecutive variables which should be true
+    #   # followed by false followed by true.
+    #   bools.must.match [repeat(false), true, false, true, repeat(false)]]
+    #
+    class RegexpConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, regexp = @params.values_at(:lhs, :regexp)
+        Gecode::Raw::extensional(@model.active_space, lhs.to_bool_var_array, 
+          regexp, *propagation_options)
+      end
+    end
   end
 end

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

@@ -0,0 +1,101 @@
+module Gecode
+  class Model
+    # Specifies an integer regexp that matches +regexp+ repeated between
+    # +at_least+ and +at_most+ times (inclusive). If +at_most+ is
+    # omitted then no upper bound is placed. If both +at_least+ and
+    # +at_most+ are omitted then no bounds are placed.
+    #
+    # See Constraints::IntEnum::Extensional::RegexpConstraint for the
+    # allowed syntax of +regexp+.
+    def repeat(regexp, at_least = nil, at_most = nil)
+      unless at_least.nil? or at_least.kind_of? Fixnum
+        raise TypeError, 
+          "Expected the at_least argument to be a Fixnum, got #{at_least.class}"
+      end
+      unless at_most.nil? or at_most.kind_of?(Fixnum)
+        raise TypeError, 
+          "Expected the at_most argument to be a Fixnum, got #{at_most.class}"
+      end
+
+      reg = Constraints::Util::Extensional.parse_regexp regexp
+      if at_most.nil?
+        if at_least.nil?
+          reg.send '*'
+        else
+          reg.send('()', at_least)
+        end
+      else
+        reg.send('()', at_least, at_most)
+      end
+    end
+
+    # Matches +regexp+ repeated zero or one time (i.e. like '?' in normal 
+    # regexps). Produces the same result as calling 
+    #   
+    #   repeat(regexp, 0, 1)
+    def at_most_once(regexp)
+      repeat(regexp, 0, 1)
+    end
+    
+    # Matches +regexp+ repeated at least one time (i.e. like '+' in normal 
+    # regexps). Produces the same result as calling 
+    #   
+    #   repeat(regexp, 1)
+    def at_least_once(regexp)
+      repeat(regexp, 1)
+    end
+
+    # Matches any of the specified +regexps+.
+    def any(*regexps)
+      regexps.inject(Gecode::Raw::REG.new) do |result, regexp|
+        result | Constraints::Util::Extensional.parse_regexp(regexp)
+      end
+    end
+  end
+
+  module Constraints::Util::Extensional
+    module_function
+
+    # Parses a regular expression over the integer domain, returning
+    # an instance of Gecode::REG .
+    #
+    # Pseudo-BNF of the integer regexp representation:
+    # regexp ::= <Fixnum> | <TrueClass> | <FalseClass> | <Gecode::Raw::REG> 
+    #          | [<regexp>, ...]
+    def parse_regexp(regexp)
+      # Check the involved types.
+      unless regexp.kind_of? Enumerable
+        regexp = [regexp]
+      end
+      regexp.to_a.flatten.each do |element|
+        unless element.kind_of?(Fixnum) or element.kind_of?(Gecode::Raw::REG) or
+            element.kind_of?(TrueClass) or element.kind_of?(FalseClass)
+          raise TypeError, 
+            "Can't translate #{element.class} into integer or boolean regexp."
+        end
+      end
+
+      # Convert it into a regexp.
+      internal_parse_regexp(regexp)
+    end
+
+    private
+
+    # Recursively converts arg into an instance of Gecode::REG. It is
+    # assumed that arg is of kind Gecode::Raw::REG, Fixnum, TrueClass,
+    # FalseClass or Enumerable.
+    def self.internal_parse_regexp(arg)
+      case arg 
+        when Gecode::Raw::REG: arg
+        when Fixnum: Gecode::Raw::REG.new(arg)
+        when TrueClass: Gecode::Raw::REG.new(1)
+        when FalseClass: Gecode::Raw::REG.new(0)
+        when Enumerable
+          # Recursively convert the elements of the arg.
+          arg.inject(Gecode::Raw::REG.new) do |regexp, element|
+            regexp += internal_parse_regexp(element)
+          end
+      end
+    end
+  end
+end