gecoder-with-gecode 0.8.3 → 0.9.0

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

@@ -1,29 +1,200 @@
-module Gecode
-  class FreeBoolVar
-    # Creates a linear expression where the bool variables are summed.
-    def +(var)
-      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-        @model) + var
+module Gecode::Bool
+  module BoolLinearOperations #:nodoc:
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) plus +op2+.
+    #
+    # ==== Examples 
+    #
+    #   # +bool1+ plus +bool2+
+    #   bool1 + bool2
+    def +(op2)
+      bool_linear_expression_operation(:+, op2)
     end
     
-    alias_method :pre_linear_mult, :* if instance_methods.include? '*'
-
-    # Creates a linear expression where the bool variable is multiplied with 
-    # a constant integer.
-    def *(int)
-      if int.kind_of? Fixnum
-        Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-          @model) * int
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) times a constant.
+    #
+    # ==== Examples 
+    #
+    #   # +bool+ times 17
+    #   bool * 17
+    def *(fixnum)
+      if fixnum.kind_of? Fixnum
+        bool_linear_expression_operation(:*, fixnum)
       else
-        pre_linear_mult(int) if respond_to? :pre_linear_mult
+        raise TypeError, "Expected fixnum, got #{fixnum.class}."
       end
     end
     
-    # Creates a linear expression where the specified variable is subtracted 
-    # from this one.
-    def -(var)
-      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-        @model) - var
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) minus +op2+.
+    #
+    # ==== Examples 
+    #
+    #   # +bool1+ minus +bool2+
+    #   bool1 - bool2
+    def -(op2)
+      bool_linear_expression_operation(:-, op2)
+    end
+
+    private
+
+    # Performs the bool linear expression operation +operator+ on self
+    # and +operand2+.
+    def bool_linear_expression_operation(operator, operand2)
+      linear_module = Linear
+      unless operand2.respond_to? :to_minimodel_lin_exp
+        operand2 = linear_module::ExpressionNode.new operand2
+      end
+      operand1 = self
+      unless operand1.respond_to? :to_minimodel_lin_exp
+        operand1 = linear_module::ExpressionNode.new(self, @model)
+      end
+      linear_module::ExpressionTree.new(operand1, operand2, operator)
+    end
+  end
+
+  module BoolOperand
+    # We include the operations and then redefine them so that they show
+    # up in the documentation.
+    include BoolLinearOperations
+
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) plus +op2+.
+    #
+    # ==== Examples 
+    #
+    #   # +bool1+ plus +bool2+
+    #   bool1 + bool2
+    def +(op2)
+      bool_linear_expression_operation(:+, op2)
+    end
+    
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) times a constant.
+    #
+    # ==== Examples 
+    #
+    #   # +bool+ times 17
+    #   bool * 17
+    def *(fixnum)
+      if fixnum.kind_of? Fixnum
+        bool_linear_expression_operation(:*, fixnum)
+      else
+        raise TypeError, "Expected fixnum, got #{fixnum.class}."
+      end
+    end
+    
+    # Produces an IntOperand representing the value of this boolean
+    # operand (0 or 1) minus +op2+.
+    #
+    # ==== Examples 
+    #
+    #   # +bool1+ minus +bool2+
+    #   bool1 - bool2
+    def -(op2)
+      bool_linear_expression_operation(:-, op2)
+    end
+  end
+
+  # A module that gathers the classes and modules used in linear constraints.
+  module Linear #:nodoc:
+    class LinearRelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        lhs, rhs, relation_type, reif_var = 
+          @params.values_at(:lhs, :rhs, :relation_type, :reif)
+        reif_var = reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        final_exp = (lhs.to_minimodel_lin_exp - rhs.to_minimodel_lin_exp)
+        if reif_var.nil?
+          final_exp.post(@model.active_space, relation_type, 
+            *propagation_options)
+        else
+          final_exp.post(@model.active_space, relation_type, reif_var, 
+            *propagation_options)
+        end
+      end
+    end
+
+    # Describes a binary tree of expression nodes which together form a linear 
+    # expression.
+    class ExpressionTree < Gecode::Int::ShortCircuitRelationsOperand #:nodoc:
+      include Gecode::Bool::BoolLinearOperations
+      attr :model
+
+      # Constructs a new expression with the specified operands.
+      def initialize(left_node, right_node, operation)
+        super(left_node.model || right_node.model)
+        @left = left_node
+        @right = right_node
+        @operation = operation
+        @model = @left.model || @right.model
+      end
+      
+      # Converts the linear expression to an instance of 
+      # Gecode::Raw::MiniModel::LinExpr
+      def to_minimodel_lin_exp
+        @left.to_minimodel_lin_exp.send(@operation, @right.to_minimodel_lin_exp)
+      end
+
+      alias_method :pre_bool_construct_receiver, :construct_receiver
+      def construct_receiver(params)
+        receiver = pre_bool_construct_receiver(params)
+        lhs = self
+        receiver.instance_eval{ @lhs = lhs }
+        class <<receiver
+          alias_method :pre_bool_equality, :==
+          def ==(op, options = {})
+            if op.respond_to? :to_bool_var
+              (@lhs - op).must.equal(0, options)
+            else
+              pre_bool_equality(op, options)
+            end
+          end
+          alias_comparison_methods
+        end
+        return receiver
+      end
+
+      def relation_constraint(relation, bool_operand_or_fix, params)
+        unless params[:negate]
+          relation_type = 
+            Gecode::Util::RELATION_TYPES[relation]
+        else
+          relation_type = 
+            Gecode::Util::NEGATED_RELATION_TYPES[relation]
+        end
+
+        unless bool_operand_or_fix.respond_to? :to_minimodel_lin_exp
+          bool_operand_or_fix = Linear::ExpressionNode.new(bool_operand_or_fix);
+        end
+
+        params.update(:rhs => bool_operand_or_fix, :relation_type => relation_type)
+        LinearRelationConstraint.new(model, params)
+      end
+    end
+    
+    # Describes a single node in a linear expression.
+    class ExpressionNode #:nodoc:
+      attr :model
+    
+      def initialize(value, model = nil)
+        unless value.respond_to?(:to_bool_var) or value.kind_of?(Fixnum)
+          raise TypeError, 'Expected bool operand or ' + 
+            "fixnum, got #{value.class}."
+        end
+        @value = value
+        @model = model
+      end
+      
+      # Converts the linear expression to an instance of 
+      # Gecode::Raw::MiniModel::LinExpr
+      def to_minimodel_lin_exp
+        expression = @value
+        if expression.respond_to? :to_bool_var
+          expression = expression.to_bool_var.bind * 1
+        end
+        expression
+      end
     end
   end
-end
+end

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

@@ -1,14 +1,35 @@
-module Gecode::Constraints::BoolEnum
-  class Expression
-    # Adds a channel constraint on the variables in the enum with the specified
-    # integer variable. Beyond the common options the channel constraint can
+module Gecode::BoolEnum
+  class BoolEnumConstraintReceiver
+    # Constrains this enumeration to "channel" +integer_operand+. This 
+    # constrains the integer operand to take value i exactly when the 
+    # operand at index i in the boolean enumeration is true and the others 
+    # are false.
+    # 
+    # Beyond the common options the channel constraint can
     # also take the following option:
     #
-    # [: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 enumeration is true 
-    #            and the rest are false.
-    def channel(int_var, options = {})
+    # [:offset]  Specifies an offset for the integer operand. If the offset is
+    #            set to k then the integer operand takes value i+k exactly 
+    #            when the operand at index i in the boolean enumeration is 
+    #            true and the rest are false.
+    # 
+    # Neither reification nor negation is supported. The int operand
+    # and the enumeration can be interchanged.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the enumeration called +option_is_selected+ to be false 
+    #   # in the first four positions and have exactly one true operand in 
+    #   # the other. 
+    #   option_is_selected.must.channel selected_option_index 
+    #   selected_option_index.must_be > 3
+    #
+    #   # Constrains the enumeration called +option_is_selected+ to be false 
+    #   # in the first five positions and have exactly one true operand in 
+    #   # the other. 
+    #   selected_option_index.must.channel(option_is_selected, :offset => 1) 
+    #   selected_option_index.must_be > 3
+    def channel(integer_operand, options = {})
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
           'is not implemented.'
@@ -17,47 +38,30 @@ module Gecode::Constraints::BoolEnum
         raise ArgumentError, 'The channel constraint does not support the ' + 
           'reification option.'
       end
-      unless int_var.kind_of? Gecode::FreeIntVar
-        raise TypeError, "Expected an integer variable, got #{int_var.class}."
+      unless integer_operand.respond_to? :to_int_var
+        raise TypeError, 'Expected an integer operand, got ' + 
+          "#{integer_operand.class}."
       end
       
-      @params.update(:rhs => int_var, :offset => options.delete(:offset) || 0)
-      @params.update(Gecode::Constraints::Util.decode_options(options))
+      @params.update(:rhs => integer_operand, 
+        :offset => options.delete(:offset) || 0)
+      @params.update(Gecode::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 }
+    # Provides commutativity with SetConstraintReceiver#channel
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_set_var }
   end
   
   # A module that gathers the classes and modules used in channel constraints
-  # involving one boolean enum and one integer variable.
+  # involving one boolean enum and one integer operand.
   module Channel #:nodoc:
-    # 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. The int variable
-    # and the enumeration can be interchanged.
-    #
-    # == Examples
-    #
-    # # Constrains the enumeration called +option_is_selected+ to be false in the
-    # # first four positions and have exactly one true variable in the other. 
-    # option_is_selected.must.channel selected_option_index 
-    # selected_option_index.must_be > 3
-    #
-    # # 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_index.must.channel(option_is_selected, :offset => 1) 
-    # selected_option_index.must_be > 3
-    class ChannelConstraint < Gecode::Constraints::Constraint
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, rhs, offset = @params.values_at(:lhs, :rhs, :offset)
-        Gecode::Raw::channel(@model.active_space, lhs.to_bool_var_array, 
-          rhs.bind, offset, *propagation_options)
+        Gecode::Raw::channel(@model.active_space, 
+          lhs.to_bool_enum.bind_array, rhs.to_int_var.bind, 
+          offset, *propagation_options)
       end
     end
   end

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

@@ -1,6 +1,18 @@
-module Gecode::Constraints::BoolEnum
-  class Expression
-    # Posts an equality constraint on the variables in the enum.
+module Gecode::BoolEnum
+  class BoolEnumConstraintReceiver
+    # Constrains all the operands in this enumeration to be equal to
+    # one of the specified tuples. Neither negation nor reification is
+    # supported.
+    #
+    # ==== Examples 
+    # 
+    #   # Constrains the three boolean operands in +bools+ to either
+    #   # be true, false, true, or false, false, true.
+    #   bools.must_be.in [[true, false, true], [false, false, true]]
+    #
+    #   # The same as above, but preferring speed over low memory usage.
+    #   bools.must_be.in([[true, false, true], [false, false, true]], 
+    #     :kind => :speed)
     def in(tuples, options = {})
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated tuple constraint is ' +
@@ -11,7 +23,7 @@ module Gecode::Constraints::BoolEnum
           'constraint.'
       end
       
-      util = Gecode::Constraints::Util
+      util = Gecode::Util
       
       # Check that the tuples are correct.
       expected_size = @params[:lhs].size
@@ -23,14 +35,28 @@ module Gecode::Constraints::BoolEnum
       
       @params[:tuples] = tuples
       @model.add_constraint Extensional::TupleConstraint.new(@model, 
-        @params.update(Gecode::Constraints::Util.decode_options(options)))
+        @params.update(Gecode::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.
+    # Constrains the sequence of operands in this enumeration to match
+    # a specified regexp in the boolean domain. Neither negation nor
+    # reification is supported.
+    #
+    # The regular expressions are specified as described in 
+    # IntEnumConstraintReceiver#match but true and false can be
+    # used instead of integers.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the two boolean operands in +bools+ to be false
+    #   # and true respectively.
+    #   bools.must.match [false, true]
+    #
+    #   # Constrains the boolean operands in +bools+ to be false,
+    #   # except for three consecutive operands which should be true
+    #   # followed by false followed by true.
+    #   bools.must.match [repeat(false), true, false, true, repeat(false)]]
+    #
     def match(regexp, options = {})
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
@@ -42,8 +68,8 @@ module Gecode::Constraints::BoolEnum
       end
 
       @params[:regexp] = 
-        Gecode::Constraints::Util::Extensional.parse_regexp regexp
-      @params.update Gecode::Constraints::Util.decode_options(options)
+        Gecode::Util::Extensional.parse_regexp regexp
+      @params.update Gecode::Util.decode_options(options)
       @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
     end
   end
@@ -51,23 +77,10 @@ module Gecode::Constraints::BoolEnum
   # A module that gathers the classes and modules used in extensional 
   # constraints.
   module Extensional #:nodoc:
-    # Describes a tuple constraint, which constrains the variables in an 
-    # boolean enumeration to be equal to one of the specified tuples. Neither 
-    # negation nor reification is supported.
-    # 
-    # == Example
-    # 
-    #   # Constrains the three boolean variables in +bools+ to either
-    #   # be true, false, true, or false, false, true.
-    #   bools.must_be.in [[true, false, true], [false, false, true]]
-    #
-    #   # The same as above, but preferring speed over low memory usage.
-    #   bools.must_be.in([[true, false, true], [false, false, true]], 
-    #     :kind => :speed)
-    class TupleConstraint < Gecode::Constraints::Constraint
+    class TupleConstraint < Gecode::Constraint #:nodoc:
       def post
         # Bind lhs.
-        lhs = @params[:lhs].to_bool_var_array
+        lhs = @params[:lhs].to_bool_enum.bind_array
 
         # Create the tuple set.
         tuple_set = Gecode::Raw::TupleSet.new
@@ -82,30 +95,11 @@ module Gecode::Constraints::BoolEnum
       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
+    class RegexpConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, regexp = @params.values_at(:lhs, :regexp)
-        Gecode::Raw::extensional(@model.active_space, lhs.to_bool_var_array, 
-          regexp, *propagation_options)
+        Gecode::Raw::extensional(@model.active_space, 
+          lhs.to_bool_enum.bind_array, regexp, *propagation_options)
       end
     end
   end

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

@@ -1,87 +1,54 @@
-module Gecode
-  module BoolEnumMethods
-    # Produces an expression that can be handled as if it was a variable 
-    # representing the conjunction of all boolean variables in the enumeration.
+module Gecode::BoolEnum
+  module BoolEnumOperand
+    # Produces a BoolOperand that represents the conjunction (AND) of all
+    # boolean operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # Conjunction of all elements in +bool_enum+.
+    #   bool_enum.conjunction
     def conjunction
-      return Gecode::Constraints::BoolEnum::Relation::ConjunctionStub.new(
-        @model, :lhs => self)
+      Relation::BoolEnumConjunctionOperand.new(@model, self)
     end
     
-    # Produces an expression that can be handled as if it was a variable 
-    # representing the disjunction of all boolean variables in the enumeration.
+    # Produces a BoolOperand that represents the disjunction (OR) of all
+    # boolean operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # Disjunction of all elements in +bool_enum+.
+    #   bool_enum.disjunction
     def disjunction
-      return Gecode::Constraints::BoolEnum::Relation::DisjunctionStub.new(
-        @model, :lhs => self)
+      Relation::BoolEnumDisjunctionOperand.new(@model, self)
     end
   end
-end
 
-module Gecode::Constraints::BoolEnum
   # A module that gathers the classes and modules used by boolean enumeration 
   # relation constraints.
   module Relation #:nodoc:
-    # Describes a CompositeStub for the conjunction constraint, which constrain
-    # the conjunction of all boolean variables in an enumeration.
-    # 
-    # == Example
-    # 
-    #   # The conjunction of all variables in +bool_enum+ must be true. I.e. all
-    #   # boolean variables must take the value true.
-    #   bool_enum.conjunction.must_be.true
-    #   
-    #   # The conjunction of all variables in +bool_enum+ must equal b1.
-    #   bool_enum.conjunction.must ==  b1
-    #   
-    #   # The conjunction of all variables in +bool_enum+ must not equal b1 and 
-    #   # b2. It's reified it with +bool+ and selects the strength +domain+.
-    #   bool_enum.conjunction.must_not.equal(b1 & b2, :reify => bool, 
-    #     :strength => :domain)
-    class ConjunctionStub < Gecode::Constraints::Bool::CompositeStub
-      def constrain_equal(variable, params, constrain)
-        enum = @params[:lhs]
-        
-        @model.add_interaction do
-          if variable.respond_to? :bind
-            bound = variable.bind
-          else
-            bound = variable ? 1 : 0
-          end
-          Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_AND,
-            enum.to_bool_var_array, bound, *propagation_options)
-        end
-        return variable
+    class BoolEnumConjunctionOperand < Gecode::Bool::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, bool_enum)
+        super model
+        @enum = bool_enum
+      end
+
+      def constrain_equal(bool_operand, constrain_domain, propagation_options)
+        Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_AND,
+          @enum.to_bool_enum.bind_array, bool_operand.to_bool_var.bind, 
+          *propagation_options)
       end
     end
     
-    # Describes a CompositeStub for the disjunction constraint, which constrain
-    # the disjunction of all boolean variables in an enumeration.
-    # 
-    # == Example
-    # 
-    #   # The disjunction of all variables in +bool_enum+ must be true. I.e. at
-    #   # least one of the boolean variables must take the value true.
-    #   bool_enum.disjunction.must_be.true
-    #   
-    #   # The disjunction of all variables in +bool_enum+ must equal b1.
-    #   bool_enum.conjunction.must ==  b1
-    #   
-    #   # The disjunction of all variables in +bool_enum+ must not equal b1 and 
-    #   # b2. It's reified it with +bool+ and selects the strength +domain+.
-    #   bool_enum.disjunction.must_not.equal(b1 & b2, :reify => bool, 
-    #     :strength => :domain)
-    class DisjunctionStub < Gecode::Constraints::Bool::CompositeStub
-      def constrain_equal(variable, params, constrain)
-        enum = @params[:lhs]
-        
-        @model.add_interaction do
-          if variable.respond_to? :bind
-            bound = variable.bind
-          else
-            bound = variable ? 1 : 0
-          end
-          Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_OR,
-            enum.to_bool_var_array, bound, *propagation_options)
-        end
+    class BoolEnumDisjunctionOperand < Gecode::Bool::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, bool_enum)
+        super model
+        @enum = bool_enum
+      end
+
+      def constrain_equal(bool_operand, constrain_domain, propagation_options)
+        Gecode::Raw::rel(@model.active_space, Gecode::Raw::BOT_OR,
+          @enum.to_bool_enum.bind_array, bool_operand.to_bool_var.bind, 
+          *propagation_options)
       end
     end
   end