gecoder-with-gecode 0.8.3 → 0.9.0

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

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

@@ -1,23 +1,26 @@
-module Gecode
-  module IntEnumMethods
-    # Specifies offsets to be used with a distinct constraint. The offsets can
-    # be specified one by one or as an array of offsets.
-    def with_offsets(*offsets)
-      if offsets.kind_of? Enumerable
-        offsets = *offsets
-      end
-      params = {:lhs => self, :offsets => offsets}
-      
-      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
-        Gecode::Constraints::IntEnum::Expression.new(m, ps)
-      end
-    end
-  end
-end
-
-module Gecode::Constraints::IntEnum
-  class Expression
-    # Posts a distinct constraint on the variables in the enum.
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # Constrains all integer operands in the enumeration to be distinct
+    # (different). The constraint can also be used with constant
+    # offsets, so that the operands, with specified offsets added, must
+    # be distinct.
+    # 
+    # The constraint does not support negation nor reification.
+    # 
+    # ==== Examples 
+    # 
+    #   # Constrains all operands in +int_enum+ to be assigned different 
+    #   # values.
+    #   int_enum.must_be.distinct
+    #   
+    #   # The same as above, but also selects that the strength +domain+ should
+    #   # be used.
+    #   int_enum.must_be.distinct(:strength => :domain)
+    #   
+    #   # Uses the offset to constrain that no number may be the previous number
+    #   # incremented by one.
+    #   numbers = int_var_array(8, 0..9)
+    #   numbers.must_be.distinct(:offsets => (1..numbers.size).to_a.reverse)
     def distinct(options = {})
       if @params[:negate]
         # The best we could implement it as from here would be a bunch of 
@@ -29,39 +32,26 @@ module Gecode::Constraints::IntEnum
         raise ArgumentError, 'Reification is not supported by the distinct ' + 
           'constraint.'
       end
-      
+
+      if options.has_key? :offsets
+        offsets = options.delete(:offsets)
+        unless offsets.kind_of? Enumerable
+          raise TypeError, 'Expected Enumerable as offsets, got ' + 
+            "#{offsets.class}."
+        end
+        @params[:offsets] = offsets
+      end
       @model.add_constraint Distinct::DistinctConstraint.new(@model, 
-        @params.update(Gecode::Constraints::Util.decode_options(options)))
+        @params.update(Gecode::Util.decode_options(options)))
     end
   end
   
   # A module that gathers the classes and modules used in distinct constraints.
   module Distinct #:nodoc:
-    # Describes a distinct constraint, which constrains all integer variables 
-    # in an enumeration to be distinct (different). The constraint can also be
-    # used with constant offsets, so that the variables, with specified offsets
-    # added, must be distinct.
-    # 
-    # The constraint does not support negation nor reification.
-    # 
-    # == Examples
-    # 
-    #   # Constrains all variables in +int_enum+ to be assigned different 
-    #   # values.
-    #   int_enum.must_be.distinct
-    #   
-    #   # The same as above, but also selects that the strength +domain+ should
-    #   # be used.
-    #   int_enum.must_be.distinct(:strength => :domain)
-    #   
-    #   # Uses the offset to constrain that no number may be the previous number
-    #   # incremented by one.
-    #   numbers = int_var_array(8, 0..9)
-    #   numbers.with_offset((1..numbers.size).to_a.reverse).must_be.distinct
-    class DistinctConstraint < Gecode::Constraints::Constraint
+    class DistinctConstraint < Gecode::Constraint #:nodoc:
       def post
         # Bind lhs.
-        @params[:lhs] = @params[:lhs].to_int_var_array
+        @params[:lhs] = @params[:lhs].to_int_enum.bind_array
         
         # Fetch the parameters to Gecode.
         params = @params.values_at(:offsets, :lhs)
@@ -71,4 +61,4 @@ module Gecode::Constraints::IntEnum
       end
     end
   end
-end
+end

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

@@ -1,65 +1,34 @@
-# A module that gathers the classes and modules used by element constraints.
-module Gecode::Constraints::IntEnum::Element #:nodoc:
-  # Describes a CompositeStub for the element constraint, which places a 
-  # constraint on a variable at the specified position in an enumeration of 
-  # integer variables. It's basically the array access of constraint 
-  # programming.
-  # 
-  # == Example
-  # 
-  #   # The variable at the +x+:th position in +int_enum+ must be larger than
-  #   # +y+.
-  #   int_enum[x].must > y
-  # 
-  #   # The price of +selected_item+ as described by +prices+ must not be 
-  #   # larger than 100.
-  #   prices = wrap_enum([500, 24, 4711, 412, 24])
-  #   prices[selected_item].must_not > 100
-  #   
-  #   # Reify the constraint that the +x+:th variable in +int_enum+ must be in 
-  #   # range 7..17 with the boolean variable +bool+ and select strength 
-  #   # +domain+.  
-  # 
-  #   int_enum[x].must_be.in(7..17, :reify => bool, :strength => :domain)
-  class ExpressionStub < Gecode::Constraints::Int::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum, position = @params.values_at(:lhs, :position)
-      if constrain
-        variable.must_be.in enum.domain_range
-      end
-      
-      # The enum can be a constant array.
-      enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
-      Gecode::Raw::element(@model.active_space, enum, 
-        position.bind, variable.bind, *propagation_options)
-    end
-  end
-  
-  # Methods needed to add support for element constraints to enums.
-  module AdditionalEnumMethods #:nodoc:
+module Gecode::IntEnum
+  module IntEnumOperand
     # This adds the adder for the methods in the modules including it. The 
     # reason for doing it so indirect is that the first #[] won't be defined 
     # before the module that this is mixed into is mixed into an enum.
-    def self.included(enum_mod)
+    def self.included(enum_mod) #:nodoc:
       enum_mod.module_eval do
-        # Now we enter the module AdditionalEnumMethods is mixed into.
+        # Now we enter the module IntEnumOperands is mixed into.
         class << self
           alias_method :pre_element_included, :included
-          def included(mod)
+          def included(mod) #:nodoc:
             mod.module_eval do
-              # Now we enter the module that the module possibly defining #[] 
-              # is mixed into.
               if instance_methods.include? '[]'
                 alias_method :pre_element_access, :[]
               end
-            
+          
+              # Produces an IntOperand representing the
+              # i:th integer operand in the enumeration, where i is the
+              # value of the integer operand used as index. Think of it
+              # as array access in the world of constraint programming.
+              # 
+              # ==== Examples 
+              # 
+              #   # The operand at the +x+:th position in +int_enum+,
+              #   # where +x+ is an integer operand.  
+              #   int_enum[x]
+              # 
               def [](*vars)
-                # Hook in an element constraint if a variable is used for array 
-                # access.
-                if vars.first.kind_of? Gecode::FreeIntVar
-                  params = {:lhs => self, :position => vars.first}
-                  return Gecode::Constraints::IntEnum::Element::ExpressionStub.new(
-                    @model, params)
+                if vars.first.respond_to? :to_int_var
+                  return Element::ElementIntOperand.new(
+                    model, self, vars.first)
                 else
                   pre_element_access(*vars) if respond_to? :pre_element_access
                 end
@@ -71,12 +40,25 @@ module Gecode::Constraints::IntEnum::Element #:nodoc:
       end
     end
   end
-end
 
-module Gecode::IntEnumMethods
-  include Gecode::Constraints::IntEnum::Element::AdditionalEnumMethods
-end
+  module Element #:nodoc:
+    class ElementIntOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, enum_op, position_int_var_op)
+        super model
+        @enum = enum_op
+        @position = position_int_var_op
+      end
 
-module Gecode::FixnumEnumMethods
-  include Gecode::Constraints::IntEnum::Element::AdditionalEnumMethods
+      def constrain_equal(int_operand, constrain, propagation_options)
+        enum = @enum.to_int_enum
+        if constrain
+          int_operand.must_be.in enum.domain_range
+        end
+
+        Gecode::Raw::element(model.active_space, enum.bind_array, 
+          @position.to_int_var.bind, int_operand.to_int_var.bind, 
+          *propagation_options)
+      end
+    end
+  end
 end

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

@@ -1,6 +1,12 @@
-module Gecode::Constraints::IntEnum
-  class Expression
-    # Posts an equality constraint on the variables in the enum.
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # Constrains all operands in the enumeration to be equal. 
+    # Neither negation nor reification is supported.
+    # 
+    # ==== Examples 
+    # 
+    #   # Constrains all operands in +int_enum+ to be equal.
+    #   int_enum.must_be.equal
     def equal(options = {})
       if @params[:negate]
         # The best we could implement it as from here would be a bunch of 
@@ -14,28 +20,18 @@ module Gecode::Constraints::IntEnum
       end
     
       @model.add_constraint Equality::EqualityConstraint.new(@model, 
-        @params.update(Gecode::Constraints::Util.decode_options(options)))
+        @params.update(Gecode::Util.decode_options(options)))
     end
   end
   
   # A module that gathers the classes and modules used in equality constraints.
   module Equality #:nodoc:
-    # Describes an equality constraint, which constrains all variables in an
-    # integer enumeration to be equal. Neither negation nor reification is 
-    # supported.
-    # 
-    # == Example
-    # 
-    #   # Constrains all variables in +int_enum+ to be equal.
-    #   int_enum.must_be.equal
-    class EqualityConstraint < Gecode::Constraints::Constraint
+    class EqualityConstraint < Gecode::Constraint #:nodoc:
       def post
-        # Bind lhs.
-        lhs = @params[:lhs].to_int_var_array
-        
-        # Fetch the parameters to Gecode.
-        Gecode::Raw::eq(@model.active_space, lhs, *propagation_options)
+        Gecode::Raw::rel(@model.active_space,
+          @params[:lhs].to_int_enum.bind_array, 
+          Gecode::Raw::IRT_EQ, *propagation_options)
       end
     end
   end
-end
+end