gecoder-with-gecode 0.7.1

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

@@ -0,0 +1,126 @@
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Initiates a sort constraint. Beyond the common options the sort constraint
+    # can also take the following options:
+    # 
+    # [:as]     Defines a target (must be an int variable enumerable) 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 int variable enumerable that should be used to store the
+    #           order of the original enum's variables 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.
+    def sorted(options = {})
+      # Extract and check options.
+      target = options.delete(:as)
+      order = options.delete(:order)
+      unless target.nil? or target.respond_to? :to_int_var_array
+        raise TypeError, 'Expected int var enum as :as, got ' + 
+          "#{target.class}."
+      end
+      unless order.nil? or order.respond_to? :to_int_var_array
+        raise TypeError, 'Expected int var enum as :order, got ' + 
+          "#{order.class}."
+      end
+      
+      # Extract standard options and convert to constraint.
+      @params.update(Gecode::Constraints::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
+      
+        @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:
+    # Describes a sort constraint which constrains a target enumeration of 
+    # integer variables to be the sorted version of another set of integer 
+    # variables. Optionally a third enumeration may be used to define the order
+    # in which the the variables should be sorted.
+    # 
+    # Neither negation nor reification is supported.
+    # 
+    # == Example
+    # 
+    #   # Constrains +sorted_numbers+ to be a sorted version of +numbers+. 
+    #   numbers.must_be.sorted(:as => sorted_numbers)
+    #   
+    #   # Constrains +sorted_numbers+ to be +numbers+ sorted in the order 
+    #   # described by the integer variable enumeration +order+. 
+    #   numbers.must_be.sorted(:as => sorted_numbers, :order => order)
+    class SortConstraintWithOptions < Gecode::Constraints::Constraint
+      def post
+        if @params[:target].nil?
+          # We must have a target.
+          lhs = @params[:lhs]
+          @params[:target] = @model.int_var_array(lhs.size, lhs.domain_range)
+        end
+        
+        # Prepare the parameters.
+        params = @params.values_at(:lhs, :target, :order, :strength).map do |param| 
+          if param.respond_to? :to_int_var_array
+            param.to_int_var_array
+          else
+            param
+          end
+        end.delete_if{ |param| param.nil? }
+        # Post the constraint.
+        Gecode::Raw::sortedness(@model.active_space, *params)
+      end
+    end
+    
+    # Describes a sort constraint which constrains an enumeration of integer 
+    # variables to be sorted. Supports reification and negation.
+    # 
+    # == Example
+    # 
+    #   # Constrains the variables in +int_enum+ to be sorted ascendingly.
+    #   int_enum.must_be.sorted
+    #   
+    #   # Reifies the constraint that the variables in +int_enum+ to be sorted 
+    #   # ascendingly with the boolean variable +is_sorted+, while selecting 
+    #   # +domain+ as strength.
+    #   int_enum.must_be.sorted(:reify => :is_sorted, :strength => :domain)
+    class SortConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        lhs, strength, reif_var = @params.values_at(:lhs, :strength, :reif)
+        using_reification = !reif_var.nil?
+        
+        # We translate the constraint into n-1 relation constraints.
+        options = {:strength => 
+          Gecode::Constraints::Util::PROPAGATION_STRENGTHS.invert[strength]}
+        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

data/lib/gecoder/interface/constraints/int_enum_constraints.rb

@@ -0,0 +1,37 @@
+module Gecode
+  module IntEnumMethods
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::IntEnum::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have enumerations of integer 
+  # variables as left hand side.
+  module Constraints::IntEnum
+    # Expressions with int enums as left hand sides.
+    class Expression < Gecode::Constraints::Expression #:nodoc:
+      # Raises TypeError unless the left hand side is an int enum.
+      def initialize(model, params)
+        super
+        
+        unless params[:lhs].respond_to? :to_int_var_array
+          raise TypeError, 'Must have int enum as left hand side.'
+        end
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int_enum/distinct'
+require 'gecoder/interface/constraints/int_enum/equality'
+require 'gecoder/interface/constraints/int_enum/channel'
+require 'gecoder/interface/constraints/int_enum/element'
+require 'gecoder/interface/constraints/int_enum/count'
+require 'gecoder/interface/constraints/int_enum/sort'
+require 'gecoder/interface/constraints/int_enum/arithmetic'

data/lib/gecoder/interface/constraints/int_var_constraints.rb

@@ -0,0 +1,58 @@
+module Gecode
+  class FreeIntVar
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::Int::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have int variables as left hand side
+  # (but not enumerations).
+  module Constraints::Int
+    # Describes an integer expression.
+    class Expression < Gecode::Constraints::Expression #:nodoc:
+    end
+    
+    # A composite expression which is an int expression with a left hand side 
+    # resulting from a previous constraint.
+    class CompositeExpression < Gecode::Constraints::CompositeExpression #:nodoc:
+      # The block given should take three parameters. The first is the variable 
+      # that should be the left hand side, if it's nil then a new one should be
+      # created. The second is the has of parameters. The block should return 
+      # the variable used as left hand side.
+      def initialize(model, params, &block)
+        super(Expression, Gecode::FreeIntVar, lambda{ model.int_var }, model, 
+          params, &block)
+      end
+    end
+    
+    # Describes a stub that produces an int variable, which can then be used 
+    # with the normal int variable constraints. An example would be the element
+    # constraint.
+    #
+    #   int_enum[int_var].must > rhs
+    #
+    # <tt>int_enum[int_var]</tt> produces an int variable which the constraint 
+    # <tt>.must > rhs</tt> is then applied to. In the above case two 
+    # constraints (and one temporary variable) are required, but in the case of 
+    # equality only one constraint is required.
+    # 
+    # Whether a constraint involving a reification stub supports negation, 
+    # reification, strength options and so on depends on the constraint on the
+    # right hand side.
+    class CompositeStub < Gecode::Constraints::CompositeStub
+      def initialize(model, params)
+        super(CompositeExpression, model, params)
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int/linear'
+require 'gecoder/interface/constraints/int/domain'
+require 'gecoder/interface/constraints/int/arithmetic'

data/lib/gecoder/interface/constraints/reifiable_constraints.rb

@@ -0,0 +1,78 @@
+module Gecode::Constraints
+  # Base class for all reifiable constraints.
+  class ReifiableConstraint < Constraint
+    # Gets the reification variable of the constraint, nil if none exists.
+    def reification_var
+      @params[:reif]
+    end
+    
+    # Sets the reification variable of the constraint, nil if none should be
+    # used.
+    def reification_var=(new_var)
+      @params[:reif] = new_var
+    end
+    
+    # Produces a disjunction of two reifiable constraints, producing a new
+    # reifiable constraint.
+    def |(constraint)
+      with_reification_variables(constraint) do |b1, b2|
+        # Create the disjunction constraint.
+        (b1 | b2).must_be.true
+      end
+    end
+    
+    # Produces a conjunction of two reifiable constraints, producing a new
+    # reifiable constraint.
+    def &(constraint)
+      with_reification_variables(constraint) do |b1, b2|
+        # Create the conjunction constraint.
+        (b1 & b2).must_be.true
+      end
+    end
+    
+    private
+    
+    # Yields two boolean variables to the specified block. The first one is 
+    # self's reification variable and the second one is the reification variable
+    # of the specified constraint. Reuses reification variables if possible,
+    # otherwise creates new ones.
+    def with_reification_variables(constraint, &block)
+      raise TypeError unless constraint.kind_of? ReifiableConstraint
+      
+      # Set up the reification variables, using existing variables if they 
+      # exist.
+      con1_holds = self.reification_var
+      con2_holds = constraint.reification_var
+      if con1_holds.nil?
+        con1_holds = @model.bool_var
+        self.reification_var = con1_holds
+      end
+      if con2_holds.nil?
+        con2_holds = @model.bool_var
+        constraint.reification_var = con2_holds
+      end
+      yield(con1_holds, con2_holds)
+    end
+    
+    # If called the negation of the constraint will be handled using the 
+    # reification variable. This means that the post method (which has to be 
+    # defined prior to calling this method) doesn't have to bother about 
+    # negation.
+    def self.negate_using_reification
+      class_eval do
+        alias_method :post_without_negation, :post
+        
+        def post
+          if @params[:negate]
+            if @params[:reif].nil?
+              # Create a reification variable if none exists.
+              @params[:reif] = @model.bool_var
+            end
+            @params[:reif].must_be.false
+          end
+          post_without_negation
+        end
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set/cardinality.rb

@@ -0,0 +1,75 @@
+module Gecode
+  class FreeSetVar
+    # Starts a constraint on the size of the set.
+    def size
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Cardinality::SizeExpressionStub.new(
+        @model, params)
+    end
+  end
+end
+
+module Gecode::Constraints::Set
+  # A module that gathers the classes and modules used in cardinality 
+  # constraints.
+  module Cardinality #:nodoc:
+    # Describes a cardinality constraint specifically for ranges. This is just
+    # a special case which is used instead of the more general composite 
+    # constraint when the target cardinality is a range. 
+    class CardinalityConstraint < Gecode::Constraints::Constraint #:nodoc:
+      def post
+        var, range = @params.values_at(:lhs, :range)
+        Gecode::Raw::cardinality(@model.active_space, var.bind, range.first, 
+          range.last)
+      end
+    end
+    
+    # A custom composite stub to change the composite expression used.
+    class CompositeStub < Gecode::Constraints::CompositeStub #:nodoc:
+      def initialize(model, params)
+        super(Expression, model, params)
+      end
+    end
+    
+    # Describes a cardinality expression started with set.size.must .
+    class Expression < Gecode::Constraints::Int::CompositeExpression #:nodoc:
+      def in(range)
+        if range.kind_of?(Range) and !@params[:negate]
+          @params.update(:range => range)
+          @model.add_constraint CardinalityConstraint.new(@model, @params)
+        else
+          super(range)
+        end
+      end
+    end
+    
+    # Describes a CompositeStub for the cardianlity constraint which constrains
+    # the cardianlity (size) of a set.
+    # 
+    # == Example
+    # 
+    #   # The size of +set+ must be within 1..17
+    #   set.size.must_be.in 1..17
+    #   
+    #   # The size must equal the integer variable +size+.
+    #   set.size.must == size
+    #   
+    #   # The size must not be larger than 17
+    #   set.size.must_not > 17
+    #   
+    #   # We reify the above with a boolean variable called +is_not_large+ and 
+    #   # select the strength +domain+.
+    #   set.size.must_not_be.larger_than(17, :reify => is_not_large, 
+    #     :strength => :domain)
+    class SizeExpressionStub < CompositeStub
+      def constrain_equal(variable, params, constrain)
+        lhs = @params[:lhs]
+        if constrain
+          variable.must_be.in lhs.lower_bound.size..lhs.upper_bound.size
+        end
+        
+        Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set/connection.rb

@@ -0,0 +1,193 @@
+module Gecode
+  class FreeSetVar
+    # Starts a constraint on the minimum value of the set.
+    def min
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Connection::MinExpressionStub.new(@model, params)
+    end
+    
+    # Starts a constraint on the maximum value of the set.
+    def max
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Connection::MaxExpressionStub.new(@model, params)
+    end
+    
+    # Starts a constraint on the sum of the set. The option :weights may 
+    # optionally be given with a hash of weights as value. If it is then the 
+    # weighted sum, using the hash as weight function, will be constrained. The
+    # option :substitutions may also be given (with a hash as value), if it is 
+    # then the sum of the set with all elements replaced according to the hash 
+    # is constrained. Elements mapped to nil by the weights or substitutions 
+    # hash are removed from the upper bound of the set. Only one of the two
+    # options may be given at the same time.
+    def sum(options = {:weights => weights = Hash.new(1)})
+      if options.empty? or options.keys.size > 1
+        raise ArgumentError, 'One of the options :weights and :substitutions, ' +
+          'or neither, must be specified.'
+      end
+      params = {:lhs => self}
+      unless options.empty?
+        case options.keys.first
+          when :substitutions: params.update(options)
+          when :weights:
+            weights = options[:weights]
+            substitutions = Hash.new do |hash, key|
+              if weights[key].nil?
+                hash[key] = nil
+              else
+                hash[key] = key * weights[key]
+              end
+            end
+            params.update(:substitutions => substitutions)
+          else raise ArgumentError, "Unrecognized option #{options.keys.first}."
+        end
+      end
+      Gecode::Constraints::Set::Connection::SumExpressionStub.new(@model, params)
+    end
+  end
+end
+
+module Gecode::Constraints::Set
+  class Expression
+    # Adds a constraint that forces specified values to be included in the 
+    # set. This constraint has the side effect of sorting the variables in 
+    # non-descending order.
+    def include(variables)
+      unless variables.respond_to? :to_int_var_array
+        raise TypeError, "Expected int var enum, got #{variables.class}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated include is not ' + 
+          'implemented.'
+      end
+      
+      @params.update(:variables => variables)
+      @model.add_constraint Connection::IncludeConstraint.new(@model, @params)
+    end
+  end
+
+  # A module that gathers the classes and modules used in connection 
+  # constraints.
+  module Connection #:nodoc:
+    # Describes a CompositeStub for the min constraint which constrains the 
+    # minimum value of a set variable.
+    # 
+    # == Examples
+    # 
+    #   # Constrains the minimum value of +set+ to be larger than 17.
+    #   set.min.must > 17
+    #   
+    #   # Constrains the minimum value of +set+ to equal the integer variable 
+    #   # +min+.
+    #   set.min.must == min
+    #   
+    #   # Constrains the minimum value of +set+ to not be larger than the 
+    #   # integer variable +ceil+.
+    #   set.min.must_not > ceil
+    #   
+    #   # The same as above but reified with the boolean variable 
+    #   # +is_not_above_ceiling+ and with the strength +domain+ applied.
+    #   set.min.must_not_be.larger_than(ceil, :reify => :is_not_above_ceiling, 
+    #     :strength => :domain) 
+    class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params, constrain)
+        set = params[:lhs]
+        if constrain
+          variable.must_be.in set.upper_bound.min..set.lower_bound.min
+        end
+        
+        Gecode::Raw::min(@model.active_space, set.bind, variable.bind)
+      end
+    end
+    
+    # Describes a CompositeStub for the max constraint which constrains the 
+    # maximum value of a set variable.
+    # 
+    # == Examples
+    # 
+    #   # Constrains the maximum value of +set+ to be larger than 17.
+    #   set.max.must > 17
+    #   
+    #   # Constrains the maximum value of +set+ to equal the integer variable 
+    #   # +max+.
+    #   set.max.must == max
+    #   
+    #   # Constrains the maximum value of +set+ to not be less than the 
+    #   # integer variable +floor+.
+    #   set.max.must_not < floor
+    #   
+    #   # The same as above but reified with the boolean variable 
+    #   # +is_not_below_floor+ and with the strength +domain+ applied.
+    #   set.max.must_not_be.less_than(ceil, :reify => :is_not_below_floor, 
+    #     :strength => :domain)
+    class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params, constrain)
+        set = params[:lhs]
+        if constrain
+          variable.must_be.in set.lower_bound.max..set.upper_bound.max
+        end
+        
+        Gecode::Raw::max(@model.active_space, set.bind, variable.bind)
+      end
+    end
+    
+    # Describes a CompositeStub for the sum constraint which constrains the 
+    # sum of all values in a set variable.
+    # 
+    # == Examples
+    # 
+    #   # Constrains the sum of all values in +set+ to be larger than 17.
+    #   set.sum.must > 17
+    #   
+    #   # Constrains the sum of all values in +set+ to equal the integer 
+    #   # variable +sum+.
+    #   set.sum.must == sum
+    #   
+    #   # Constrains the sum of all values in +set+ to not be larger than the 
+    #   # integer variable +resources+.
+    #   set.sum.must_not > resources
+    #   
+    #   # The same as above but reified with the boolean variable 
+    #   # +not_over_budget+ and with the strength +domain+ applied.
+    #   set.sum.must_not_be.larger_than(resources, :reify => :not_over_budget, 
+    #     :strength => :domain)
+    class SumExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params, constrain)
+        set, subs = params.values_at(:lhs, :substitutions)
+        lub = set.upper_bound.to_a
+        lub.delete_if{ |e| subs[e].nil? }
+        substituted_lub = lub.map{ |e| subs[e] }
+        if constrain
+          # Compute the theoretical bounds of the weighted sum. This is slightly
+          # sloppy since we could also use the contents of the greatest lower 
+          # bound.
+          min = substituted_lub.find_all{ |e| e < 0}.inject(0){ |x, y| x + y }
+          max = substituted_lub.find_all{ |e| e > 0}.inject(0){ |x, y| x + y }
+          variable.must_be.in min..max
+        end
+
+        Gecode::Raw::weights(@model.active_space, lub, substituted_lub, 
+          set.bind, variable.bind)
+      end
+    end
+    
+    # Describes an include constraint, which constrains the set to include the
+    # values of the specified enumeration of integer variables. 
+    # 
+    # The constraint has the side effect of sorting the integer variables in a 
+    # non-descending order. It does not support reification nor negation.
+    # 
+    # == Examples
+    # 
+    #   # Constrain +set+ to include the values of all variables in 
+    #   # +int_enum+.
+    #   set.must.include int_enum 
+    class IncludeConstraint < Gecode::Constraints::Constraint
+      def post
+        set, variables = @params.values_at(:lhs, :variables)
+        Gecode::Raw::match(@model.active_space, set.bind, 
+          variables.to_int_var_array)
+      end
+    end
+  end
+end