gecoder-with-gecode 0.8.3 → 0.9.0

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

@@ -1,149 +1,150 @@
-class Gecode::FreeIntVar
-  # Initiates an arithmetic absolute value constraint.
-  def abs
-    Gecode::Constraints::Int::Arithmetic::AbsExpressionStub.new(@model, 
-      :lhs => self)
-  end
-  
-  # Initiates an arithmetic squared value constraint.
-  def squared
-    Gecode::Constraints::Int::Arithmetic::SquaredExpressionStub.new(@model, 
-      :lhs => self)
-  end
-
-  # Initiates an arithmetic squared root constraint.
-  def sqrt
-    Gecode::Constraints::Int::Arithmetic::SquareRootExpressionStub.new(@model, 
-      :lhs => self)
-  end
-  alias_method :square_root, :sqrt
-
+module Gecode::Int
+  module IntOperand
+    # Produces an IntOperand representing the absolute value of this 
+    # operand.
+    #
+    # ==== Examples 
+    #   
+    #   # The absolute value of +int_op+.
+    #   int_op.abs
+    def abs
+      Arithmetic::IntAbsOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing this operand squared.
+    #
+    # ==== Examples 
+    #   
+    #   # The value of +int_op*int_op+.
+    #   int_op.squared
+    def squared
+      Arithmetic::IntSquaredOperand.new(@model, self)
+    end
 
-  alias_method :pre_arith_mult, :* if instance_methods.include? '*'
-  
-  # Begins a multiplication constraint involving the two int variable.
-  def *(var)
-    if var.kind_of? Gecode::FreeIntVar
-      Gecode::Constraints::Int::Arithmetic::MultExpressionStub.new(
-        @model, :lhs => self, :var => var)
-    else
-      pre_arith_mult(var) if respond_to? :pre_arith_mult
+    # Produces an IntOperand representing the square root of this 
+    # operand rounded down.
+    #
+    # ==== Examples 
+    #   
+    #   # The square root of +int_op+, rounded down.
+    #   int_op.square_root
+    def square_root
+      Arithmetic::IntSquareRootOperand.new(@model, self)
     end
-  end
-end
+    alias_method :sqrt, :square_root
 
-# A module that gathers the classes and modules used by arithmetic constraints.
-module Gecode::Constraints::Int::Arithmetic #:nodoc:
-  # Describes a CompositeStub for absolute value constraints, which constrain
-  # the absolute value of an integer variable.
-  # 
-  # == Examples
-  #   
-  #   # The absolute value of +x+ must be less than 2.
-  #   x.abs.must < 2
-  #   
-  #   # The absolute value of +x+ must be in the range 5..7, with +bool+ as 
-  #   # reification variable and +value+ as strength.
-  #   x.abs.must_be.in(5..7, :reify => bool, :strength => :value)
-  class AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        bounds = [lhs.min.abs, lhs.max.abs]
-        variable.must_be.in bounds.min..bounds.max
+
+    alias_method :pre_arith_mult, :* 
+    
+    # Produces a new IntOperand representing this operand times
+    # +int_operand+.
+    #
+    # ==== Examples 
+    #   
+    #   # The value of +int_op1+ times +int_op2+.
+    #   int_op1 * int_op2
+    def *(int_operand)
+      if int_operand.respond_to? :to_int_var
+        Arithmetic::IntMultOperand.new(@model, self, int_operand)
+      else
+        pre_arith_mult(int_operand) 
       end
-      
-      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
     end
   end
   
-  # Describes a CompositeStub for multiplication constraint, which constrain
-  # the value of the multiplication of two variables.
-  # 
-  # == Examples
-  #   
-  #   # The value of +x*y+ must be equal to their sum.
-  #   (x*y).must == x + y
-  #   
-  #   # The value of +x*y+ must be less than 17, with +bool+ as reification 
-  #   # variable and +domain+ as strength.
-  #   (x*y).must_be.less_than(17, :reify => bool, :strength => :domain)
-  class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs, lhs2 = @params.values_at(:lhs, :var)
-      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.must_be.in products.min..products.max
+  # A module that gathers the classes and modules used by arithmetic 
+  # constraints.
+  module Arithmetic #:nodoc:
+    class IntAbsOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
       end
 
-      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
-        variable.bind, *propagation_options)
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          bounds = [int_op.min.abs, int_op.max.abs]
+          bounds << 0 if int_op.min < 0
+          int_operand.must_be.in bounds.min..bounds.max
+        end
+        
+        Gecode::Raw::abs(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
     end
-  end
-  
-  # Describes a CompositeStub for the squared constraint, which constrain
-  # the squared value of the variable.
-  # 
-  # == Examples
-  #   
-  #   # The value of +x*x+ must be equal to y.
-  #   x.squared.must == y
-  #   
-  #   # The value of +x*x+ must be less than or equal to 16, with +bool+ as 
-  #   # reification variable and +domain+ as strength.
-  #   x.squared.must_be.less_or_equal(16, :reify => bool, :strength => :domain)
-  class SquaredExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        min = lhs.min; max = lhs.max
-        products = [min*max, min*min, max*max]
-        variable.must_be.in products.min..products.max
+    
+    class IntMultOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, op1, op2)
+        super model
+        @op1 = op1
+        @op2 = op2
       end
 
-      Gecode::Raw::sqr(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
-    end
-  end
-  
-  # Describes a CompositeStub for the square root constraint, which constrain
-  # the rounded down square root of the variable.
-  # 
-  # == Examples
-  #   
-  #   # The square root of +x+, rounded down, must equal y.
-  #   x.square_root.must == y   
-  #
-  #   # The square root of +x+, rounded down, must be larger than 17, with 
-  #   # +bool+ as reification variable and +domain+ as strength.
-  #   x.square_root.must_be.larger_than(17, :reify => bool, :strength => :domain)
-  class SquareRootExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      lhs = @params[:lhs]
-      if constrain
-        max = lhs.max
-        if max < 0
-          # The left hand side does not have a real valued square root.
-          upper_bound = 0
-        else
-          upper_bound = Math.sqrt(max).floor;
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op1, int_op2 = @op1.to_int_var, @op2.to_int_var
+        if constrain
+          a_min = int_op1.min; a_max = int_op1.max
+          b_min = int_op2.min; b_max = int_op2.max
+          products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
+          int_operand.must_be.in products.min..products.max
         end
-        
-        min = lhs.min
-        if min < 0
-          lower_bound = 0
-        else
-          lower_bound = Math.sqrt(min).floor;
+
+        Gecode::Raw::mult(@model.active_space, int_op1.to_int_var.bind, 
+          int_op2.to_int_var.bind, int_operand.to_int_var.bind, 
+          *propagation_options)
+      end
+    end
+    
+    class IntSquaredOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          min = int_op.min; max = int_op.max
+          products = [min*max, min*min, max*max]
+          int_operand.must_be.in products.min..products.max
         end
-        
-        variable.must_be.in lower_bound..upper_bound
+
+        Gecode::Raw::sqr(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+    
+    class IntSquareRootOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_op)
+        super model
+        @int = int_op
       end
 
-      Gecode::Raw::sqrt(@model.active_space, lhs.bind, variable.bind, 
-        *propagation_options)
+      def constrain_equal(int_operand, constrain, propagation_options)
+        int_op = @int.to_int_var
+        if constrain
+          max = int_op.max
+          if max < 0
+            # The left hand side does not have a real valued square root.
+            upper_bound = 0
+          else
+            upper_bound = Math.sqrt(max).floor;
+          end
+          
+          min = int_op.min
+          if min < 0
+            lower_bound = 0
+          else
+            lower_bound = Math.sqrt(min).floor;
+          end
+          
+          int_operand.must_be.in lower_bound..upper_bound
+        end
+
+        Gecode::Raw::sqrt(@model.active_space, int_op.to_int_var.bind, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
     end
   end
 end

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