gecoder 0.8.3 → 0.9.0

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

@@ -0,0 +1,141 @@
+module Gecode::Int
+  class IntConstraintReceiver
+    # Constrains the integer operand to equal +int_operand_or_fixnum+.
+    # #equal and #equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must equal +int2+
+    #   int1.must == int2
+    #
+    #   # +int+ must equal 17
+    #   int.must == 17
+    #   
+    #   # +int1+ must equal +int2+. We reify the constraint with 
+    #   # +bool+ and select +domain+ as strength.
+    #   int1.must.equal(int2, :reify => bool, :strength => :domain)
+    def ==(int_operand_or_fixnum, options = {})
+      comparison(:==, int_operand_or_fixnum, options)
+    end
+
+    # Constrains the integer operand to be strictly greater than
+    # +int_operand_or_fixnum+. #greater and #greater_than are 
+    # aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be strictly greater than +int2+
+    #   int1.must > int2
+    #
+    #   # +int+ must be strictly greater than 17
+    #   int.must > 17
+    #   
+    #   # +int1+ must be strictly greater than +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must_be.greater_than(int2, :reify => bool, :strength => :domain)
+    def >(int_operand_or_fixnum, options = {})
+      comparison(:>, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be greater than or equal to
+    # +int_operand_or_fixnum+. #greater_or_equal and 
+    # #greater_than_or_equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be greater than or equal to +int2+
+    #   int1.must >= int2
+    #
+    #   # +int+ must be greater than or equal to 17
+    #   int.must >= 17
+    #   
+    #   # +int1+ must be greater than or equal to +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must.greater_or_equal(int2, :reify => bool, :strength => :domain)
+    def >=(int_operand_or_fixnum, options = {})
+      comparison(:>=, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be strictly less than
+    # +int_operand_or_fixnum+. #lesser and #lesser_than are 
+    # aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be strictly less than +int2+
+    #   int1.must < int2
+    #
+    #   # +int+ must be strictly less than 17
+    #   int.must < 17
+    #   
+    #   # +int1+ must be strictly less than +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must_be.less_than(int2, :reify => bool, :strength => :domain)
+    def <(int_operand_or_fixnum, options = {})
+      comparison(:<, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be less than or equal to
+    # +int_operand_or_fixnum+. #less_or_equal and 
+    # #less_than_or_equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be less than or equal to +int2+
+    #   int1.must <= int2
+    #
+    #   # +int+ must be less than or equal to 17
+    #   int.must <= 17
+    #   
+    #   # +int1+ must be less than or equal to +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must.less_or_equal(int2, :reify => bool, :strength => :domain)
+    def <=(int_operand_or_fixnum, options = {})
+      comparison(:<=, int_operand_or_fixnum, options)
+    end
+    
+    alias_comparison_methods
+    
+    private
+
+    # Helper for the comparison methods. The reason that they are not
+    # generated in a loop is that it would mess up the RDoc.
+    def comparison(name, int_operand_or_fixnum, options)
+      unless int_operand_or_fixnum.respond_to?(:to_int_var) or 
+          int_operand_or_fixnum.kind_of?(Fixnum)
+        raise TypeError, "Expected int operand or integer, got " + 
+          "#{int_operand_or_fixnum.class}."
+      end
+
+      unless @params[:negate]
+        relation_type = Gecode::Util::RELATION_TYPES[name]
+      else
+        relation_type = Gecode::Util::NEGATED_RELATION_TYPES[name]
+      end
+      @params.update Gecode::Util.decode_options(options)
+      @model.add_constraint Relation::RelationConstraint.new(@model, 
+        @params.update(:relation_type => relation_type, 
+                       :rhs => int_operand_or_fixnum))
+    end
+  end
+
+  # A module that gathers the classes and modules used in relation constraints.
+  module Relation #:nodoc:
+    class RelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        # Fetch the parameters to Gecode.
+        lhs, relation, rhs, reif_var = 
+          @params.values_at(:lhs, :relation_type, :rhs, :reif)
+          
+        rhs = rhs.to_int_var.bind if rhs.respond_to? :to_int_var
+        if reif_var.nil?
+          Gecode::Raw::rel(@model.active_space, lhs.to_int_var.bind, 
+            relation, rhs, *propagation_options)
+        else
+          Gecode::Raw::rel(@model.active_space, lhs.to_int_var.bind, 
+            relation, rhs, reif_var.to_bool_var.bind, *propagation_options)
+        end
+      end
+    end
+  end
+end

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

@@ -1,72 +1,63 @@
-module Gecode::IntEnumMethods
-  # Starts an arithmetic max constraint. This overrides the normal enum max, but
-  # that's not a problem since variables are not implemented to be comparable.
-  def max
-    return Gecode::Constraints::IntEnum::Arithmetic::MaxExpressionStub.new(
-      @model, :lhs => self)
-  end
-  
-  # Starts an arithmetic min constraint. This overrides the normal enum min, but
-  # that's not a problem since variables are not implemented to be comparable.
-  def min
-    return Gecode::Constraints::IntEnum::Arithmetic::MinExpressionStub.new(
-      @model, :lhs => self)
+module Gecode::IntEnum
+  module IntEnumOperand
+    # Produces an IntOperand representing the maximum value of the 
+    # integer operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The maximum of +int_enum+.
+    #   int_enum.max
+    def max
+      Arithmetic::IntEnumMaxOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing the minimum value of the 
+    # integer operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The minimum of +int_enum+.
+    #   int_enum.min
+    def min
+      Arithmetic::IntEnumMinOperand.new(@model, self)
+    end
   end
-end
 
-# A module that gathers the classes and modules used by arithmetic constraints.
-module Gecode::Constraints::IntEnum::Arithmetic #:nodoc:
-  # Describes a CompositeStub for the max constraint, which constrains the 
-  # maximum value of the integer variables in an enumeration.
-  # 
-  # == Example
-  # 
-  #   # The maximum must be positive.
-  #   int_enum.max.must > 0
-  #   
-  #   # The maximum must equal a integer variable +max+.
-  #   int_enum.max.must == max
-  #   
-  #   # The maximum must not be negative. The constraint is reified with the 
-  #   # boolean variable +is_negative+ and strength +domain+ is selected.
-  #   int_enum.max.must_not_be.less_than(0, :reify => is_negative, 
-  #     :strength => :domain)
-  class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum = @params[:lhs]
-      if constrain
-        variable.must_be.in enum.domain_range
+  # A module that gathers the classes and modules used by arithmetic 
+  # constraints.
+  module Arithmetic #:nodoc:
+    class IntEnumMaxOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_enum)
+        super model
+        @int_enum = int_enum
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        enum = @int_enum.to_int_enum
+        if constrain
+          int_operand.must_be.in enum.domain_range
+        end
+        
+        Gecode::Raw::max(@model.active_space, enum.bind_array, 
+          int_operand.to_int_var.bind, *propagation_options)
       end
-      
-      Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
-        variable.bind, *propagation_options)
     end
-  end
-  
-  # Describes a CompositeStub for the min constraint, which constrains the 
-  # minimum value of the integer variables in an enumeration.
-  # 
-  # == Example
-  # 
-  #   # The minimum must be positive.
-  #   int_enum.min.must > 0
-  #   
-  #   # The minimum must equal a integer variable +min+.
-  #   int_enum.min.must == min
-  #   
-  #   # The minimum must not be non-positive. The constraint is reified with the 
-  #   # boolean variable +is_positive+ and strength +domain+ is selected.
-  #   int_enum.min.must_not_be.less_or_equal(0, :reify => is_positive, 
-  #     :strength => :domain)
-  class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum = @params[:lhs]
-      if constrain
-        variable.must_be.in enum.domain_range
+    
+    class IntEnumMinOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_enum)
+        super model
+        @int_enum = int_enum
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        enum = @int_enum.to_int_enum
+        if constrain
+          int_operand.must_be.in enum.domain_range
+        end
+        
+        Gecode::Raw::min(@model.active_space, enum.bind_array, 
+          int_operand.to_int_var.bind, *propagation_options)
       end
-      
-      Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
-        variable.bind, *propagation_options)
     end
   end
 end

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

@@ -1,34 +1,8 @@
-module Gecode::Constraints::IntEnum
-  class Expression
-    # Adds a channel constraint on the variables in the enum with the specified
-    # other set or int enum.
-    def channel(enum, options = {})
-      if @params[:negate]
-        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
-          'is not implemented.'
-      end
-      unless enum.respond_to?(:to_int_var_array)
-        raise TypeError, "Expected int enum, got #{enum.class}."
-      end
-      if options.has_key? :reify
-        raise ArgumentError, 'The channel constraints does not support the ' +
-          'reification option.'
-      end
-      
-      @params.update(Gecode::Constraints::Util.decode_options(options))
-      @params.update(:rhs => enum)
-      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
-    end
-    
-    provide_commutivity(:channel){ |rhs, _| rhs.respond_to? :to_set_var_array }
-  end
-  
-  # A module that gathers the classes and modules used in channel constraints.
-  module Channel #:nodoc:
-    # Describes a channel constraint which "channels" two enumerations of 
-    # integer variables or one enumeration of integer variables and one 
-    # enumeration of set variables. Channel constraints are used to give 
-    # access to multiple viewpoints when modelling. 
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # Constrains this enumeration to "channel" +int_enum+.  Channel
+    # constraints are used to give access to multiple viewpoints when
+    # modelling. 
     # 
     # The channel constraint can be thought of as constraining the arrays to 
     # be each other's inverses. I.e. if the i:th value in the first enumeration
@@ -37,9 +11,9 @@ module Gecode::Constraints::IntEnum
     # 
     # Neither reification nor negation is supported.
     # 
-    # == Example
+    # ==== Examples 
     # 
-    # Lets say that we’re modelling a sequence of numbers that must be distinct
+    # Lets say that we're modelling a sequence of numbers that must be distinct
     # and that we want access to the following two view simultaneously.
     # 
     # === First view
@@ -77,12 +51,36 @@ module Gecode::Constraints::IntEnum
     # 
     #   elements.must.channel positions
     # 
-    class ChannelConstraint < Gecode::Constraints::Constraint
+    def channel(int_enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      unless int_enum.respond_to? :to_int_enum
+        raise TypeError, "Expected int enum, got #{int_enum.class}."
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraints does not support the ' +
+          'reification option.'
+      end
+      
+      @params.update(Gecode::Util.decode_options(options))
+      @params.update(:rhs => int_enum)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+    
+    # Provides commutativity with SetEnumConstraintReceiver#channel .
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_set_enum }
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints.
+  module Channel #:nodoc:
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, rhs = @params.values_at(:lhs, :rhs)
-        Gecode::Raw::channel(@model.active_space, lhs.to_int_var_array, 
-          rhs.to_int_var_array, *propagation_options)
+        Gecode::Raw::channel(@model.active_space, lhs.to_int_enum.bind_array,
+          rhs.to_int_enum.bind_array, *propagation_options)
       end
     end
   end
-end
+end

data/lib/gecoder/interface/constraints/int_enum/count.rb

@@ -1,91 +1,66 @@
-module Gecode
-  module IntEnumMethods
-    # Specifies that a specific element should be counted, starting a count
-    # constraint. The element can be either an int var or a fixnum.
-    def count(element)
-      unless element.kind_of?(FreeIntVar) or element.kind_of?(Fixnum)
-        raise TypeError, 'Elements used with count can not be of type ' + 
-          "#{element.class}."
-      end
-      params = {:lhs => self, :element => element}
-      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
-        Gecode::Constraints::IntEnum::Count::Expression.new(m, ps)
+module Gecode::IntEnum
+  module IntEnumOperand
+    # Produces a new IntOperand representing the number of times
+    # +int_operand_or_fixnum+ is present in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The number of times 17 occurs in +int_enum+.
+    #   int_enum.count(17)
+    #
+    #   # The number of times +int_operand+ occurs in +int_enum+.
+    #   int_enum.count(int_operand)
+    def count(int_operand_or_fixnum)
+      unless int_operand_or_fixnum.respond_to? :to_int_var or 
+          int_operand_or_fixnum.kind_of?(Fixnum)
+        raise TypeError, 'Expected integer operand of fixnum, got ' + 
+          "#{int_operand_or_fixnum.class}."
       end
+      Count::IntEnumCountOperand.new(@model, self, int_operand_or_fixnum)
     end
   end
-end
 
-# A module that gathers the classes and modules used in count constraints.
-module Gecode::Constraints::IntEnum::Count #:nodoc:
-  # Describes an expression 
-  class Expression < Gecode::Constraints::IntEnum::Expression #:nodoc:
-    def initialize(model, params)
-      super
-      unless params[:negate]
-        @method_relations = Gecode::Constraints::Util::RELATION_TYPES
-      else
-        @method_relations = Gecode::Constraints::Util::NEGATED_RELATION_TYPES
+  # A module that gathers the classes and modules used in count constraints.
+  module Count #:nodoc:
+    class IntEnumCountOperand < Gecode::Int::ShortCircuitRelationsOperand #:nodoc:
+      def initialize(model, int_enum, element)
+        super model
+        @enum = int_enum
+        @element = element
+      end
+      
+      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
+        
+        params.update(:enum => @enum, :element => @element, 
+          :rhs => int_operand_or_fix, :relation_type => relation_type)
+        CountConstraint.new(@model, params)
       end
     end
     
-    Gecode::Constraints::Util::RELATION_TYPES.each_pair do |name, type|
-      class_eval <<-"end_code"
-        def #{name}(expression, options = {})
-          unless expression.kind_of?(Fixnum) or 
-              expression.kind_of?(Gecode::FreeIntVar)
-            raise TypeError, 'Invalid right hand side of count constraint: ' + 
-              "\#{expression.class}."
-          end
+    class CountConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        enum, element, relation_type, rhs = 
+          @params.values_at(:enum, :element, :relation_type, :rhs)
         
-          relation = @method_relations[:#{name}]
-          @params.update(Gecode::Constraints::Util.decode_options(options))
-          @params.update(:rhs => expression, :relation_type => relation)
-          @model.add_constraint CountConstraint.new(@model, @params)
+        # Bind variables if needed.
+        unless element.kind_of? Fixnum
+          element = element.to_int_var.bind
         end
-      end_code
-    end
-    alias_comparison_methods
-  end
-  
-  # Describes a count constraint, which constrains the number of times a value
-  # (constant or a variable) may occurr in an enumeration of integer variable.
-  # 
-  # All relations available for +SimpleRelationConstraint+ can be used with
-  # count constraints. Negation and reification is supported.
-  # 
-  # == Examples
-  # 
-  #   # Constrain +int_enum+ to not contain 0 exactly once.
-  #   int_enum.count(0).must_not == 1
-  #   
-  #   # Constrain +int_enum+ to contain +x+ exactly +x_count+ times.
-  #   int_enum.count(x).must == x_count
-  #   
-  #   # Reifies the constraint that +int_enum+ has +x+ zeros with the boolean
-  #   # variable +has_x_zeros+ and selects the strength +domain+.
-  #   int_enum.count(0).must.equal(x, :reify => has_x_zeros, 
-  #     :strength => :domain)
-  class CountConstraint < Gecode::Constraints::ReifiableConstraint
-    def post
-      lhs, element, relation_type, rhs, reif_var = 
-        @params.values_at(:lhs, :element, :relation_type, :rhs, :reif)
-      
-      # Bind variables if needed.
-      element = element.bind if element.respond_to? :bind
-      rhs = rhs.bind if rhs.respond_to? :bind
-      
-      # Post the constraint to gecode.
-      if reif_var.nil?
-        Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
+        unless rhs.kind_of? Fixnum
+          rhs = rhs.to_int_var.bind
+        end
+        
+        # Post the constraint to gecode.
+        Gecode::Raw::count(@model.active_space, enum.to_int_enum.bind_array, 
           element, relation_type, rhs, *propagation_options)
-      else
-        # We use a proxy int variable to get the reification.
-        proxy = @model.int_var(rhs.min..rhs.max)
-        rel = Gecode::Constraints::Util::RELATION_TYPES.invert[relation_type]
-        proxy.must.send(rel, @params[:rhs], :reify => reif_var)
-        Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
-          element, Gecode::Raw::IRT_EQ, proxy.bind, *propagation_options)
       end
     end
   end
-end
+end