gecoder-with-gecode 0.9.0-x86-mswin32-60

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

@@ -0,0 +1,66 @@
+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
+
+  # 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
+    
+    class CountConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        enum, element, relation_type, rhs = 
+          @params.values_at(:enum, :element, :relation_type, :rhs)
+        
+        # Bind variables if needed.
+        unless element.kind_of? Fixnum
+          element = element.to_int_var.bind
+        end
+        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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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 
+        # reified pairwise equality constraints. 
+        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
+          'implemented.'
+      end
+      unless options[:reify].nil?
+        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::Util.decode_options(options)))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in distinct constraints.
+  module Distinct #:nodoc:
+    class DistinctConstraint < Gecode::Constraint #:nodoc:
+      def post
+        # Bind lhs.
+        @params[:lhs] = @params[:lhs].to_int_enum.bind_array
+        
+        # Fetch the parameters to Gecode.
+        params = @params.values_at(:offsets, :lhs)
+        params.delete_if{ |x| x.nil? }
+        params.concat propagation_options
+        Gecode::Raw::distinct(@model.active_space, *params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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) #:nodoc:
+      enum_mod.module_eval do
+        # Now we enter the module IntEnumOperands is mixed into.
+        class << self
+          alias_method :pre_element_included, :included
+          def included(mod) #:nodoc:
+            mod.module_eval do
+              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)
+                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
+              end
+            end
+            pre_element_included(mod)
+          end
+        end
+      end
+    end
+  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
+
+      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

@@ -0,0 +1,37 @@
+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 
+        # reified pairwise inequality constraints.
+        raise Gecode::MissingConstraintError, 'A negated equality is not ' + 
+          'implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the equality ' + 
+          'constraint.'
+      end
+    
+      @model.add_constraint Equality::EqualityConstraint.new(@model, 
+        @params.update(Gecode::Util.decode_options(options)))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in equality constraints.
+  module Equality #:nodoc:
+    class EqualityConstraint < Gecode::Constraint #:nodoc:
+      def post
+        Gecode::Raw::rel(@model.active_space,
+          @params[:lhs].to_int_enum.bind_array, 
+          Gecode::Raw::IRT_EQ, *propagation_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+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 ' +
+          'not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the tuple ' + 
+          'constraint.'
+      end
+      
+      util = Gecode::Util
+      
+      # Check that the tuples are correct.
+      expected_size = @params[:lhs].size
+      util::Extensional.perform_tuple_checks(tuples, expected_size) do |tuple|
+        unless tuple.all?{ |x| x.kind_of? Fixnum }
+          raise TypeError, 'All tuples must contain Fixnum.'
+        end
+      end
+    
+      @params[:tuples] = tuples
+      @model.add_constraint Extensional::TupleConstraint.new(@model, 
+        @params.update(util.decode_options(options)))
+    end
+
+    # 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
+    #
+    # The regular expressions are specified using arrays, integers and a
+    # few methods provided by Model. Arrays are used to group the
+    # integers in sequences that must be matched. The following array
+    # describes a regular expression matching a 1 followed by a 7.
+    #
+    #   [1, 7]
+    #
+    # Arrays can be nested or left out when not needed. I.e. the above
+    # is semantically equal to
+    #
+    #   [[[1], 7]]
+    #
+    # A couple of methods provided by Model are used to express patterns 
+    # beyond mere sequences:
+    #
+    # [Model#repeat] Used for specifying patterns that include patterns
+    #                that may be repeated a given number of times. The 
+    #                number of times to repeat a pattern can be specified 
+    #                using a lower and upper bound, but the bounds can be 
+    #                omitted to for instance allow an expression to be 
+    #                repeated any number of times.
+    # [Model#any]    Used for specifying alternatives.
+    # 
+    # Additionally Model#at_least_once and Model#at_most_once are
+    # provided as convenience methods.
+    #
+    # ==== Examples 
+    #
+    #   # Matches 1 followed by any number of 2s.
+    #   [1, repeat(2)]
+    #
+    #   # Semantically the same as above. It just has a bunch of
+    #   # needless brackets thrown in.
+    #   [[1], [repeat([2])]]
+    #
+    #   # Matches 1 followed by [a 2 followed by a 3] at least two times.
+    #   # Matches e.g. 1, 2, 3, 2, 3
+    #   [1, repeat([2, 3], 2)]
+    #
+    #   # Matches between one and two [2 followed by [at least three 1]] 
+    #   # followed by between three and four 3. Matches e.g. 
+    #   # 2, 1, 1, 1, 2, 1, 1, 1, 3, 3, 3
+    #   [repeat([2, repeat(1, 3], 1, 2), repeat(3, 3, 4)]
+    #
+    #   # Matches [1, 2 or 3] followed by 4. Matches e.g. 2, 4
+    #   [any(1, 2, 3), 4]
+    #
+    #   # Matches 0 followed by [[1 followed by 2] or [3 followed by 5]]. 
+    #   # Matches e.g. 0, 1, 2 as well as 0, 3, 5
+    #   [0, any([1, 2], [3, 5])]
+    #
+    #   # Matches 0 followed by [[[1 followed by 7] at least two times] 
+    #   # or [[8, 9], at most two times]. Matches e.g. 
+    #   # 0, 1, 7, 1, 7, 1, 7 as well as 0, 8, 9
+    #   [0, any(repeat([1, 7], 2), repeat([8, 9], 0, 2)]
+    #
+    #   # Matches 0 followed by at least one 1.
+    #   [0, at_least_once(1)]
+    #
+    #   # Exactly the same as the above.
+    #   [0, repeat(1, 1)]
+    #
+    #   # Matches 0 followed by at least one [[1 followed by 7] or [3
+    #   # followed by 2]]. Matches e.g. 0, 1, 7, 3, 2, 1, 7
+    #   [0, at_least_once(any([1, 7], [3, 2]]
+    #
+    #   # Matches 0 followed by at either [[1 followed by 7] at least once] 
+    #   # or [[3 followed by 2] at least once]. Matches e.g. 
+    #   # 0, 1, 7, 1, 7 but does _not_ match 0, 1, 7, 3, 2, 1, 7
+    #   [0, any(at_least_once([1, 7]), at_least_once([3, 2])]
+    #
+    #   # Matches 0, followed by at most one 1. Matches 0 as well as 
+    #   # 0, 1
+    #   [0, at_most_once(1)]
+    #
+    #   # Exactly the same as the above.
+    #   [0, repeat(1, 0, 1)]
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the two integer operands in +numbers+ to have
+    #   # values 1 and 7.
+    #   numbers.must.match [1, 7]
+    #
+    #   # 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 operands in +numbers+ to 
+    #   # contain 47 or 11, each followed by at least two
+    #   # 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)
+    #
+    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_enum.bind_array, regexp, *propagation_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # Constrains the elements in this enumeration to be sorted in ascending 
+    # order. The following options can be given in addition to the
+    # common constraint options:
+    # 
+    # [:as]     Defines a target (must be an IntEnum) that will
+    #           hold the sorted version of the original enumerable. The original
+    #           enumerable will not be affected (i.e. will not necessarily be 
+    #           sorted)
+    # [:order]  Sets an IntEnum that should be used to store the
+    #           order of the original enum's operands when sorted. The original
+    #           enumerable will not be affected (i.e. will not necessarily be 
+    #           sorted)
+    # 
+    # If neither of those options are specified then the original enumerable
+    # will be constrained to be sorted (otherwise not). Sort constraints with
+    # options do not allow negation.
+    #
+    # ==== Examples 
+    #
+    #   # Constrain +numbers+ to be sorted.
+    #   numbers.must_be.sorted
+    #
+    #   # Constrain +numbers+ to not be sorted.
+    #   numbers.must_not_be.sorted
+    # 
+    #   # Constrain +sorted_numbers+ to be a sorted version of +numbers+. 
+    #   numbers.must_be.sorted(:as => sorted_numbers)
+    #
+    #   # Constrain +order+ to be the order in which +numbers+ has to be
+    #   # ordered to be sorted.
+    #   numbers.must_be.sorted(:order => order)
+    #   
+    #   # Constrain +sorted_numbers+ to be +numbers+ sorted in the order 
+    #   # described by the IntEnum +order+. 
+    #   numbers.must_be.sorted(:as => sorted_numbers, :order => order)
+    #
+    #   # Constrains +numbers+ to be sorted, reifying with the boolean 
+    #   # operand +is_sorted+, while selecting +domain+ as strength.
+    #   numbers.must_be.sorted(:reify => :is_sorted, :strength => :domain)
+    def sorted(options = {})
+      # Extract and check options.
+      target = options.delete(:as)
+      order = options.delete(:order)
+      unless target.nil? or target.respond_to? :to_int_enum
+        raise TypeError, 'Expected int var enum as :as, got ' + 
+          "#{target.class}."
+      end
+      unless order.nil? or order.respond_to? :to_int_enum
+        raise TypeError, 'Expected int var enum as :order, got ' + 
+          "#{order.class}."
+      end
+      
+      # Extract standard options and convert to constraint.
+      reified = !options[:reify].nil?
+      @params.update(Gecode::Util.decode_options(options))
+      if target.nil? and order.nil?
+        @model.add_constraint Sort::SortConstraint.new(@model, @params)
+      else
+        # Do not allow negation.
+        if @params[:negate]
+          raise Gecode::MissingConstraintError, 'A negated sort with options ' +
+            'is not implemented.'
+        end
+        if reified
+          raise ArgumentError, 'Reification is not supported by the sorted ' + 
+            'constraint.'
+        end
+      
+        @params.update(:target => target, :order => order)
+        @model.add_constraint Sort::SortConstraintWithOptions.new(@model, 
+          @params)
+      end
+    end
+  end
+
+  # A module that gathers the classes and modules used in sort constraints.
+  module Sort #:nodoc:
+    class SortConstraintWithOptions < Gecode::Constraint #:nodoc:
+      def post
+        if @params[:target].nil?
+          # We must have a target.
+          lhs = @params[:lhs].to_int_enum
+          @params[:target] = @model.int_var_array(lhs.size, lhs.domain_range)
+        end
+        
+        # Prepare the parameters.
+        params = @params.values_at(:lhs, :target, :order).map do |param| 
+          if param.respond_to? :to_int_enum
+            param.to_int_enum.bind_array
+          else
+            param
+          end
+        end.delete_if{ |param| param.nil? }
+        params.concat propagation_options
+        
+        # Post the constraint.
+        Gecode::Raw::sorted(@model.active_space, *params)
+      end
+    end
+    
+    class SortConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        lhs, strength, kind, reif_var = 
+          @params.values_at(:lhs, :strength, :kind, :reif)
+        using_reification = !reif_var.nil?
+        
+        # We translate the constraint into n-1 relation constraints.
+        options = {
+          :strength => 
+            Gecode::Util::PROPAGATION_STRENGTHS.invert[strength],
+          :kind => 
+            Gecode::Util::PROPAGATION_KINDS.invert[kind]
+        }
+        if using_reification
+          reification_variables = @model.bool_var_array(lhs.size - 1)
+        end
+        (lhs.size - 1).times do |i|
+          first, second = lhs[i, 2]
+          rel_options = options.clone
+          if using_reification
+            # Reify each relation constraint and then bind them all together.
+            rel_options[:reify] = reification_variables[i]
+          end
+          first.must_be.less_than_or_equal_to(second, rel_options)
+        end
+        if using_reification
+          reification_variables.conjunction.must == reif_var
+        end
+      end
+      negate_using_reification
+    end
+  end
+end