gecoder 0.8.3 → 0.9.0

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

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

@@ -1,7 +1,17 @@
-module Gecode::Constraints::IntEnum
-  class Expression
-    # Posts a tuple constraint on the variables in the enum, constraining them
-    # to equal one of the specified tuples.
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # 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 two integer operands in +numbers+ to either have 
+    #   # values 1 and 7, or values 47 and 11.
+    #   numbers.must_be.in [[1,7], [47,11]]
+    #
+    #   # The same as above, but preferring speed over low memory usage.
+    #   numbers.must_be.in([[1,7], [47,11]], :kind => :speed)
     def in(tuples, options = {})
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated tuple constraint is ' +
@@ -12,7 +22,7 @@ module Gecode::Constraints::IntEnum
           'constraint.'
       end
       
-      util = Gecode::Constraints::Util
+      util = Gecode::Util
       
       # Check that the tuples are correct.
       expected_size = @params[:lhs].size
@@ -27,64 +37,9 @@ module Gecode::Constraints::IntEnum
         @params.update(util.decode_options(options)))
     end
 
-    # Adds a constraint that forces the enumeration to match the
-    # specified regular expression over the integer domain. The regular
-    # expression is expressed using arrays and integers. See
-    # IntEnum::Extensional::RegexpConstraint for more information and examples of
-    # such regexps.
-    def match(regexp, options = {})
-      if @params[:negate]
-        raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
-          'is not implemented.'
-      end
-      unless options[:reify].nil?
-        raise ArgumentError, 'Reification is not supported by the regexp ' + 
-          'constraint.'
-      end
-
-      @params[:regexp] = 
-        Gecode::Constraints::Util::Extensional.parse_regexp regexp
-      @params.update Gecode::Constraints::Util.decode_options(options)
-      @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
-    end
-  end
-  
-  # A module that gathers the classes and modules used in extensional 
-  # constraints.
-  module Extensional #:nodoc:
-    # Describes a tuple constraint, which constrains all the variables in an 
-    # enumeration of integer variables to be equal to one of the specified 
-    # tuples. Neither negation nor reification is supported.
-    # 
-    # == Example
-    # 
-    #   # Constrains the two integer variables in +numbers+ to either have 
-    #   # values 1 and 7, or values 47 and 11.
-    #   numbers.must_be.in [[1,7], [47,11]]
-    #
-    #   # The same as above, but preferring speed over low memory usage.
-    #   numbers.must_be.in([[1,7], [47,11]], :kind => :speed)
-    class TupleConstraint < Gecode::Constraints::Constraint
-      def post
-        # Bind lhs.
-        lhs = @params[:lhs].to_int_var_array
-
-        # Create the tuple set.
-        tuple_set = Gecode::Raw::TupleSet.new
-        @params[:tuples].each do |tuple|
-          tuple_set.add tuple
-        end
-        tuple_set.finalize
-
-        # Post the constraint.
-        Gecode::Raw::extensional(@model.active_space, lhs, tuple_set, 
-          *propagation_options)
-      end
-    end
-
-    # Describes a regexp constraint, which constrains the enumeration of
-    # integer variables to match a specified regexp in the integer
-    # domain. Neither negation nor reification is supported.
+    # Constrains the sequence of operands in this enumeration to match
+    # a specified regexp in the integer domain. Neither negation nor
+    # reification is supported.
     #
     # == Regexp syntax
     #
@@ -114,7 +69,7 @@ module Gecode::Constraints::IntEnum
     # Additionally Model#at_least_once and Model#at_most_once are
     # provided as convenience methods.
     #
-    # === Examples
+    # ==== Examples 
     #
     #   # Matches 1 followed by any number of 2s.
     #   [1, repeat(2)]
@@ -166,28 +121,66 @@ module Gecode::Constraints::IntEnum
     #   # Exactly the same as the above.
     #   [0, repeat(1, 0, 1)]
     #
-    # == Example
+    # ==== Examples 
     #
-    #   # Constrains the two integer variables in +numbers+ to have
+    #   # Constrains the two integer operands in +numbers+ to have
     #   # values 1 and 7.
     #   numbers.must.match [1, 7]
     #
-    #   # Constrains the integer variables in +numbers+ to contain the
+    #   # Constrains the integer operands in +numbers+ to contain the
     #   # value 47 followed by 11, with all other values set to -1.
     #   numbers.must.match [repeat(-1), 47, 11, repeat(-1)]
     #
-    #   # Constrains exactly three of the integer variables in +numbers+ to 
+    #   # Constrains exactly three of the integer operands in +numbers+ to 
     #   # contain 47 or 11, each followed by at least two
-    #   # variables set to -1. All other variables are constrained to
+    #   # operands set to -1. All other operands are constrained to
     #   # equal -1.
     #   numbers.must.match repeat([repeat(-1), any(11, 47), 
     #                              repeat(-1, 2)], 3, 3)
     #
-    class RegexpConstraint < Gecode::Constraints::Constraint
+    def match(regexp, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
+          'is not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the regexp ' + 
+          'constraint.'
+      end
+
+      @params[:regexp] = 
+        Gecode::Util::Extensional.parse_regexp regexp
+      @params.update Gecode::Util.decode_options(options)
+      @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in extensional 
+  # constraints.
+  module Extensional #:nodoc:
+    class TupleConstraint < Gecode::Constraint #:nodoc:
+      def post
+        # Bind lhs.
+        lhs = @params[:lhs].to_int_enum.bind_array
+
+        # Create the tuple set.
+        tuple_set = Gecode::Raw::TupleSet.new
+        @params[:tuples].each do |tuple|
+          tuple_set.add tuple
+        end
+        tuple_set.finalize
+
+        # Post the constraint.
+        Gecode::Raw::extensional(@model.active_space, lhs, tuple_set, 
+          *propagation_options)
+      end
+    end
+
+    class RegexpConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, regexp = @params.values_at(:lhs, :regexp)
-        Gecode::Raw::extensional(@model.active_space, lhs.to_int_var_array, 
-          regexp, *propagation_options)
+        Gecode::Raw::extensional(@model.active_space, 
+          lhs.to_int_enum.bind_array, regexp, *propagation_options)
       end
     end
   end