gecoder 0.8.3 → 0.9.0

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

@@ -1,13 +1,19 @@
-module Gecode::Constraints::Int
-  class Expression
+module Gecode::Int
+  class IntConstraintReceiver
     alias_method :pre_channel_equals, :==
     
-    # Constrains the integer variable to be equal to the specified boolean 
-    # variable. I.e. constrains the integer variable to be 1 when the boolean
-    # variable is true and 0 if the boolean variable is false.
+    # Constrains the integer operand to be equal to the specified boolean 
+    # operand. I.e. constrains the integer operand to be 1 when the boolean
+    # operand is true and 0 if the boolean operand is false.
+    #
+    # ==== Examples 
+    #
+    #   # The integer operand +int+ must be one exactly when the boolean 
+    #   # operand +bool+ is true.
+    #   int.must == bool
     def ==(bool, options = {})
-      unless @params[:lhs].kind_of?(Gecode::FreeIntVar) and 
-          bool.kind_of?(Gecode::FreeBoolVar)
+      unless @params[:lhs].respond_to? :to_int_var and 
+          bool.respond_to? :to_bool_var
         return pre_channel_equals(bool, options)
       end
       
@@ -20,42 +26,26 @@ module Gecode::Constraints::Int
           'constraint.'
       end
       
-      @params.update(Gecode::Constraints::Util.decode_options(options))
+      @params.update(Gecode::Util.decode_options(options))
       @params[:rhs] = bool
       @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
     end
     
     alias_comparison_methods
     
-    # Adds a channel constraint on the integer variable and the variables in 
-    # the specifed enum of boolean variables. 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 enumration is true 
-    #            and the rest are false.
-    provide_commutivity(:channel){ |rhs, _| rhs.respond_to? :to_bool_var_array }
+    # Provides commutativity with BoolEnumConstraintReceiver#channel .
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_bool_enum }
   end
   
   # A module that gathers the classes and modules used in channel constraints
-  # involving a single integer variable.
+  # involving a single integer operand.
   module Channel #:nodoc:
-    # Describes a channel constraint that constrains an integer variable to be 
-    # 1 if a boolean variable is true, and 0 when the boolean variable is false. 
-    # Does not support negation nor reification.
-    #
-    # == Examples
-    #
-    #   # The integer variable +x+ must be one exactly when the boolean 
-    #   # variable +bool+ is true.
-    #   x.must == bool
-    class ChannelConstraint < Gecode::Constraints::Constraint
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, rhs = @params.values_at(:lhs, :rhs)
-        Gecode::Raw::channel(@model.active_space, lhs.bind, rhs.bind,
-          *propagation_options)
+        Gecode::Raw::channel(@model.active_space, lhs.to_int_var.bind, 
+          rhs.to_bool_var.bind, *propagation_options)
       end
     end
   end
-end
+end

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

@@ -1,8 +1,34 @@
-module Gecode::Constraints::Int
-  class Expression
-    # Creates a domain constraint using the specified domain.
+module Gecode::Int
+  class IntConstraintReceiver
+    # Creates a domain constraint using the specified domain, specified
+    # as an enumeration of integers. The integer operand is constrained
+    # to take a value in the domain.  Domains should be specified as
+    # ranges if possible.
+    # 
+    # ==== Examples 
+    # 
+    #   # +x+ must be in the range 1..10
+    #   x.must_be.in 1..10
+    #   
+    #   # +x+ must not be in the range -5...5
+    #   x.must_not_be.in -5...5
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # operand +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in(-5...5, :reify => bool, :strength => :value)
+    #
+    #   # +x+ must be in the enumeration [3,5,7].
+    #   x.must_be.in [3,5,7]
+    #   
+    #   # +x+ must not be in the enumeration [5,6,7,17].
+    #   x.must_not_be.in [5,6,7,17]
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # operand +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in([5,6,7,17], :reify => bool, :strength => :value)
+    #
     def in(domain, options = {})
-      @params.update(Gecode::Constraints::Util.decode_options(options))
+      @params.update(Gecode::Util.decode_options(options))
       @params[:domain] = domain
       if domain.kind_of? Range
         @model.add_constraint Domain::RangeDomainConstraint.new(@model, @params)
@@ -17,28 +43,17 @@ module Gecode::Constraints::Int
   
   # A module that gathers the classes and modules used in domain constraints.
   module Domain #:nodoc:
-    # Range domain constraints specify that an integer variable must be 
-    # contained within a specified range of integers. Supports reification and
-    # negation.
-    # 
-    # == Examples
-    # 
-    #   # +x+ must be in the range 1..10
-    #   x.must_be.in 1..10
-    #   
-    #   # +x+ must not be in the range -5...5
-    #   x.must_not_be.in -5...5
-    #   
-    #   # Specifies the above, but but reifies the constraint with the boolean 
-    #   # variable +bool+ and specified +value+ as strength.
-    #   x.must_not_be.in(-5...5, :reify => bool, :strength => :value)
-    class RangeDomainConstraint < Gecode::Constraints::ReifiableConstraint
+    # Range domain constraints specify that an integer operand must be 
+    # contained within a specified range of integers.
+    class RangeDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
         var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
           
-        (params = []) << var.bind
-        params << domain.first << domain.last
-        params << reif_var.bind if reif_var.respond_to? :bind
+        (params = []) << var.to_int_var.bind
+        last = domain.last
+        last -= 1 if domain.exclude_end?
+        params << domain.first << last
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
         params.concat propagation_options
         
         Gecode::Raw::dom(@model.active_space, *params)
@@ -46,27 +61,15 @@ module Gecode::Constraints::Int
       negate_using_reification
     end
     
-    # Enum domain constraints specify that an integer variable must be contained
-    # in an enumeration of integers. Supports reification and negation.
-    # 
-    # == Examples
-    # 
-    #   # +x+ must be in the enumeration [3,5,7].
-    #   x.must_be.in [3,5,7]
-    #   
-    #   # +x+ must not be in the enumeration [5,6,7,17].
-    #   x.must_not_be.in [5,6,7,17]
-    #   
-    #   # Specifies the above, but but reifies the constraint with the boolean 
-    #   # variable +bool+ and specified +value+ as strength.
-    #   x.must_not_be.in(-[5,6,7,17], :reify => bool, :strength => :value)
-    class EnumDomainConstraint < Gecode::Constraints::ReifiableConstraint
+    # Enum domain constraints specify that an integer operand must be contained
+    # in an enumeration of integers.
+    class EnumDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
         var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
         
-        (params = []) << var.bind
-        params << Gecode::Constraints::Util.constant_set_to_int_set(domain)
-        params << reif_var.bind if reif_var.respond_to? :bind
+        (params = []) << var.to_int_var.bind
+        params << Gecode::Util.constant_set_to_int_set(domain)
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
         params.concat propagation_options
         
         Gecode::Raw::dom(@model.active_space, *params)
@@ -74,4 +77,4 @@ module Gecode::Constraints::Int
       negate_using_reification
     end
   end
-end
+end

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

@@ -1,156 +1,72 @@
-module Gecode
-  class FreeIntVar
-    # Creates a linear expression where the int variables are summed.
-    def +(var)
-      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-        @model) + var
+module Gecode::Int
+  module IntOperand
+    # Produces a new IntOperand representing this operand plus 
+    # +int_operand_or_fixnum+.
+    #
+    # ==== Examples 
+    #
+    #   # +int1+ plus +int2+
+    #   int1 + int2
+    #
+    #   # +int+ plus 17
+    #   int + 17
+    def +(int_operand_or_fixnum)
+      int_linear_expression_operation(:+, int_operand_or_fixnum)
     end
     
-    alias_method :pre_linear_mult, :* if instance_methods.include? '*'
+    # Produces a new IntOperand representing this operand minus 
+    # +int_operand_or_fixnum+. 
+    #
+    # ==== Examples 
+    #
+    #   # +int1+ minus +int2+
+    #   int1 - int2
+    #
+    #   # +int+ minus 17
+    #   int - 17
+    def -(int_operand_or_fixnum)
+      int_linear_expression_operation(:-, int_operand_or_fixnum)
+    end
 
-    # Creates a linear expression where the int variable is multiplied with 
-    # a constant integer.
-    def *(int)
-      if int.kind_of? Fixnum
-        Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-          @model) * int
+    # Produces a new IntOperand representing this operand times a 
+    # constant. 
+    #
+    # ==== Examples 
+    #
+    #   # +int+ times 17
+    #   int * 17
+    def *(fixnum)
+      if fixnum.kind_of? Fixnum
+        int_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
-    end
-  end
-  
-  module Constraints::Int
-    class Expression #:nodoc:
-      # Add some relation selection based on whether the expression is negated.
-      alias_method :pre_linear_initialize, :initialize
-      def initialize(model, params)
-        pre_linear_initialize(model, params)
-        unless params[:negate]
-          @method_relations = Constraints::Util::RELATION_TYPES
-        else
-          @method_relations = Constraints::Util::NEGATED_RELATION_TYPES
-        end
-      end
-      
-      # Define the relation methods.
-      Constraints::Util::RELATION_TYPES.each_key do |name|
-        module_eval <<-"end_code"
-          def #{name}(expression, options = {})
-            relation = @method_relations[:#{name}]
-            @params.update(
-              Gecode::Constraints::Util.decode_options(options))
-            if self.simple_expression? and simple_expression?(expression)
-              # A relation constraint is enough.
-              add_relation_constraint(relation, expression)
-            else
-              add_linear_constraint(relation, expression)
-            end
-          end
-        end_code
-      end
-      alias_comparison_methods
-      
-      protected
-      
-      # Checks whether the given expression is simple enough to be used in a 
-      # simple relation constraint. Returns true if it is, false otherwise. If
-      # no expression is given then the this expression's left hand side is 
-      # checked.
-      def simple_expression?(expression = nil)
-        if expression.nil?
-          simple_expression?(@params[:lhs])
-        else
-          expression.kind_of?(Gecode::FreeIntVar) or
-            expression.kind_of?(Gecode::FreeBoolVar) or
-            expression.kind_of?(Fixnum)
-        end
-      end
-      
-      private
-      
-      # Places the linear constraint corresponding to the specified (integer)
-      # relation type (as specified by Gecode) in relation to the specifed 
-      # expression.
-      # 
-      # Raises TypeError if the element is of a type that doesn't allow a 
-      # relation to be specified.
-      def add_linear_constraint(relation_type, right_hand_side)
-        # Bind parameters.
-        lhs = @params[:lhs]
-        if lhs.kind_of?(Gecode::FreeIntVar) or lhs.kind_of?(Gecode::FreeBoolVar)
-          lhs = lhs * 1 # Convert to Gecode::Raw::LinExp
-        end
-        if not (right_hand_side.respond_to? :to_minimodel_lin_exp or
-            right_hand_side.kind_of?(Gecode::FreeIntVar) or
-            right_hand_side.kind_of?(Gecode::FreeBoolVar) or  
-            right_hand_side.kind_of?(Fixnum))
-          raise TypeError, 'Invalid right hand side of linear equation.'
-        end
-        
-        @params.update(:relation_type => relation_type, :lhs => lhs, 
-          :rhs => right_hand_side)
-        @model.add_constraint Linear::LinearConstraint.new(@model, @params)
+
+    private
+
+    # Performs the int linear expression operation +operator+ on self
+    # and +operand2+.
+    def int_linear_expression_operation(operator, operand2)
+      unless operand2.respond_to? :to_minimodel_lin_exp
+        operand2 = Linear::ExpressionNode.new operand2
       end
-      
-      # Places the relation constraint corresponding to the specified (integer)
-      # relation type (as specified by Gecode) in relation to the specifed 
-      # element.
-      def add_relation_constraint(relation_type, element)
-        @model.add_constraint Linear::SimpleRelationConstraint.new(@model, 
-          @params.update(:relation_type => relation_type, :element => element))
+      operand1 = self
+      unless operand1.respond_to? :to_minimodel_lin_exp
+        operand1 = Linear::ExpressionNode.new(self, @model)
       end
+      Linear::ExpressionTree.new(operand1, operand2, operator)
     end
   end
-  
+
   # A module that gathers the classes and modules used in linear constraints.
-  module Constraints::Int::Linear #:nodoc:
-    # Linear constraints specify that an integer variable must have a linear 
-    # equation containing variables must hold. The same relations and options
-    # used in +SimpleRelationConstraint+ can also be used for linear 
-    # constraints.
-    # 
-    # Boolean variables can also be used instead of integer variables. In that
-    # case a boolean variable assigned true is equal to 1 and a boolean variable
-    # assigned false is equal to 0. There is one exception: boolean variables 
-    # can not be used alone as left hand side.
-    # 
-    # Do not mix boolean and integer variables. Even if possible it's not 
-    # supported, and might be removed in the future.
-    # 
-    # == Examples
-    # 
-    #   # The sum of the int variables +x+ and +y+ must equal +z+ + 3.
-    #   (x + y).must == z + 3
-    #   
-    #   # Another way of writing the above. 
-    #   z.must == x + y - 3
-    #   
-    #   # The inequality 10(x + y) > 3x must not hold. 
-    #   (x + y)*10.must_not > x*3
-    #   
-    #   # Specifies the above, but reifies the constraint with the boolean 
-    #   # variable +bool+ and gives it propagation strength +domain+.
-    #   (x + y)*10.must_not_be.greater_than(x*3, :reify => bool, :strength => :domain)
-    class LinearConstraint < Gecode::Constraints::ReifiableConstraint
+  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.bind if reif_var.respond_to? :bind
-        if rhs.respond_to? :to_minimodel_lin_exp
-          rhs = rhs.to_minimodel_lin_exp
-        elsif rhs.respond_to? :bind
-          rhs = rhs.bind * 1
-        end
-
-        final_exp = (lhs.to_minimodel_lin_exp - rhs)
+        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)
@@ -161,102 +77,18 @@ module Gecode
       end
     end
 
-    # Simple relation constraints specify that an integer variable must have a
-    # specified relation to a constant integer or another integer variable. The 
-    # following relations are supported (the aliases of each relation are also 
-    # listed).
-    # 
-    # * <, lesser, lesser_than
-    # * >, greater, greater_than
-    # * >=, greater_or_equal, greater_than_or_equal_to
-    # * <=, less_or_equal, less_than_or_equal_to
-    # * ==, equal, equal_to
-    # 
-    # Each can be negated by using +must_not+ instead of +must+.
-    # 
-    # Two options (given as a hash) are available:
-    # 
-    # [strength] Specifies the propagation strength of the constraint. Must be
-    #            one of +value+, +bounds+, +domain+ and +default+. The
-    #            strength generally progresses as +value+ -> +bounds+ -> 
-    #            +domain+ (+value+ being the weakest, but usually cheapest, 
-    #            while +domain+ is the strongest but usually costly).
-    # [reify]    Specifies a boolean variable that should be used for 
-    #            reification (see +ReifiableConstraint+).
-    # 
-    # == Examples
-    # 
-    #   # Int variable +x+ must not equal 0.
-    #   x.must_not.equal(0)
-    #   
-    #   # Another way of writing the above. 
-    #   x.must_not == 0
-    #   
-    #   # +x+ must be strictly larger than +y+.
-    #   x.must > y
-    #   
-    #   # Specifies the above, but reifies the constraint with the boolean 
-    #   # variable +bool+.
-    #   x.must_be.greater_than(y, :reify => bool)
-    class SimpleRelationConstraint < Gecode::Constraints::ReifiableConstraint
-      def post
-        # Fetch the parameters to Gecode.
-        lhs, relation, rhs, reif_var = 
-          @params.values_at(:lhs, :relation_type, :element, :reif)
-          
-        rhs = rhs.bind if rhs.respond_to? :bind
-        if reif_var.nil?
-          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
-            *propagation_options)
-        else
-          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
-            reif_var.bind, *propagation_options)
-        end
-      end
-    end
-  
-    # Helper methods for linear expressions. Classes mixing in this module must
-    # have a method #model which gives the model the expression is operating in. 
-    module Helper #:nodoc:
-      include Gecode::Constraints::LeftHandSideMethods
-      
-      private
-    
-      OPERATION_TYPES = [:+, :-, :*]
-    
-      public
-    
-      # Define methods for the available operations.
-      OPERATION_TYPES.each do |name|
-        module_eval <<-"end_code"
-          def #{name}(expression)
-            unless expression.kind_of? ExpressionTree
-              expression = ExpressionNode.new(expression)
-            end
-            ExpressionTree.new(self, expression, :#{name})
-          end
-        end_code
-      end
-      
-      private
-      
-      # Produces an expression for the lhs module.
-      def expression(params)
-        params.update(:lhs => self)
-        Gecode::Constraints::Int::Expression.new(model, params)
-      end
-    end
-    
     # Describes a binary tree of expression nodes which together form a linear 
     # expression.
-    class ExpressionTree #:nodoc:
-      include Helper
-    
-      # Constructs a new expression with the specified variable
+    class ExpressionTree < Gecode::Int::ShortCircuitRelationsOperand #:nodoc:
+      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 
@@ -264,20 +96,35 @@ module Gecode
       def to_minimodel_lin_exp
         @left.to_minimodel_lin_exp.send(@operation, @right.to_minimodel_lin_exp)
       end
-      
-      # Fetches the space that the expression's variables is in.
-      def model
-        @left.model || @right.model
+
+      def relation_constraint(relation, int_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 int_operand_or_fix.respond_to? :to_minimodel_lin_exp
+          int_operand_or_fix = Linear::ExpressionNode.new(int_operand_or_fix);
+        end
+
+        params.update(:lhs => self, :rhs => int_operand_or_fix, 
+          :relation_type => relation_type)
+        LinearRelationConstraint.new(model, params)
       end
     end
     
     # Describes a single node in a linear expression.
     class ExpressionNode #:nodoc:
-      include Helper
-    
       attr :model
     
       def initialize(value, model = nil)
+        unless value.respond_to?(:to_int_var) or value.kind_of?(Fixnum)
+          raise TypeError, 'Expected int operand or fixnum, ' + 
+            "got #{value.class}."
+        end
         @value = value
         @model = model
       end
@@ -286,12 +133,11 @@ module Gecode
       # Gecode::Raw::MiniModel::LinExpr
       def to_minimodel_lin_exp
         expression = @value
-        if expression.respond_to? :bind
-          # Minimodel requires that we do this first.
-          expression = expression.bind * 1
+        if expression.respond_to? :to_int_var
+          expression = expression.to_int_var.bind * 1
         end
         expression
       end
     end
   end
-end
+end