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

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

@@ -0,0 +1,75 @@
+# A module containing constraints that have set_enum[set] as left hand
+# side.
+module Gecode::SelectedSet #:nodoc:
+  # A SelectedSetOperand is an uncommon operand that results from calling 
+  # SetEnumOperand#[] with a SetOperand. It facilitates placing the 
+  # constraints defined in SelectedSetConstraintReceiver
+  #
+  # ==== Examples 
+  #
+  # Producing a SelectedSetOperand from +set_enum+ and +set_operand+:
+  #
+  #   set_enum[set_operand]
+  #
+  class SelectedSetOperand
+    include Gecode::Operand 
+
+    # Constructs a new selected set operand from +set_enum+ and +set+.
+    def initialize(set_enum, set) #:nodoc:
+      unless set_enum.respond_to? :to_set_enum
+        raise TypeError, "Expected set enum operand, got #{set_enum.class}."
+      end
+      unless set.respond_to? :to_set_var
+        raise TypeError, "Expected set operand, got #{set.class}."
+      end
+
+      @set_enum = set_enum
+      @set = set
+    end
+
+    # Returns the set enum and set that make up the selected set
+    # operand.
+    def to_selected_set #:nodoc:
+      return @set_enum, @set
+    end
+
+    def model #:nodoc:
+      @set_enum.model
+    end
+
+    private
+
+    def construct_receiver(params)
+      SelectedSetConstraintReceiver.new(model, params)
+    end
+  end
+
+  # SelectedSetConstraintReceiver contains all constraints that can be
+  # placed on a SelectedSetOperand.
+  #
+  # Constraints are placed by calling SelectedSetOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # SelectedSetConstraintReceiver from which the desired constraint can 
+  # be used.
+  #
+  # ==== Examples 
+  #
+  # Constrains the sets in +set_enum+ that are selected by +set_operand+ to be
+  # disjoint. This uses SetEnumOperand#[] and
+  # SelectedSetConstraintReceiver#disjoint. 
+  #
+  #   set_enum[set_operand].must_be.disjoint
+  #
+  class SelectedSetConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is a selected set operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_selected_set
+        raise TypeError, 'Must have selected set operand as left hand side.'
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/selected_set/select'

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

@@ -0,0 +1,65 @@
+module Gecode::Set
+  module SetOperand
+    # Produces an IntOperand representing the size of the set.
+    #
+    # ==== Examples 
+    #
+    #   # The size of +set+.
+    #   set.size
+    def size
+      Cardinality::SetSizeOperand.new(@model, self)
+    end
+  end
+
+  # 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::Constraint #:nodoc:
+      def post
+        var, range = @params.values_at(:lhs, :range)
+        Gecode::Raw::cardinality(@model.active_space, var.to_set_var.bind, 
+          range.first, range.last)
+      end
+    end
+    
+    class SetSizeOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, set_op)
+        super model
+        @set = set_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        set = @set.to_set_var
+        if constrain
+          int_operand.must_be.in set.lower_bound.size..set.upper_bound.size
+        end
+        
+        Gecode::Raw::cardinality(@model.active_space, set.bind, 
+          int_operand.to_int_var.bind)
+      end
+
+      alias_method :pre_cardinality_construct_receiver, :construct_receiver
+      def construct_receiver(params)
+        receiver = pre_cardinality_construct_receiver(params)
+        set = @set
+        receiver.instance_eval{ @set = set }
+        class <<receiver 
+          alias_method :in_without_short_circuit, :in
+          def in(range, options = {})
+            if range.kind_of?(Range) and !@params[:negate] and 
+                !options.has_key?(:reify)
+              @params.update(:lhs => @set, :range => range)
+              @model.add_constraint CardinalityConstraint.new(@model, @params)
+            else
+              in_without_short_circuit(range, options)
+            end
+          end
+        end
+        return receiver
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Gecode::Set
+  class SetConstraintReceiver
+    # Constrains this set to channel +bool_enum+. The set is constrained
+    # to include value i exactly when the operand at index i in the
+    # boolean enumeration is true.
+    # 
+    # Neither reification nor negation is supported. The boolean enum and set
+    # can be interchanged.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains the enumeration of boolean operands called +bools+ to at
+    #   # least have the first and third operands set to true 
+    #   set.must_be.superset_of [0, 2]
+    #   set.must.channel bools
+    #
+    #   # An alternative way of writing the above.
+    #   set.must_be.superset_of [0, 2]
+    #   bools.must.channel set
+    def channel(bool_enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraint does not support the ' + 
+          'reification option.'
+      end
+      unless bool_enum.respond_to? :to_bool_enum
+        raise TypeError, 'Expected an enum of bool operands, ' + 
+          "got #{bool_enum.class}."
+      end
+      
+      @params.update(:rhs => bool_enum)
+      @params.update Gecode::Set::Util.decode_options(options)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints
+  # involving one set operand and a boolean enum.
+  module Channel #:nodoc:
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, rhs.to_bool_enum.bind_array, 
+          lhs.to_set_var.bind)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Gecode::Set
+  module SetOperand
+    # Produces an IntOperand representing the minimum of the set.
+    #
+    # ==== Examples 
+    #
+    #  # The minimum of +set+.
+    #  set.min
+    def min
+      Connection::SetMinOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing the maximum of the set.
+    #
+    # ==== Examples 
+    #
+    #  # The maximum of +set+.
+    #  set.max
+    def max
+      Connection::SetMaxOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing the sum of the values in the
+    # set. One of the following options may also be given:
+    # [:weights]       Produces the weighted sum using the specified hash 
+    #                  of weights. The hash should map each value to 
+    #                  that value's weight.
+    # [:substitutions] Produces the sum of the set with all elements 
+    #                  replaced according to the hash.
+    # 
+    # Elements not included in the weights or substitutions hash are 
+    # removed from the upper bound of the set.
+    #
+    # ==== Examples 
+    #
+    #   # The sum of +set+.
+    #   set.sum
+    #
+    #   # The sum of +set+ with primes < 10 given twice the weight.
+    #   set.sum(:weights => {2 => 2, 3 => 2, 5 => 2, 7 => 2})
+    #
+    #   # The sum of +set+ with odd values in [1,6] being counted as 1.
+    #   set.sum(:substitutions => {1 => 1, 3 => 1, 5 => 1})
+    def sum(options = {:weights => weights = Hash.new(1)})
+      if options.empty? or options.keys.size > 1
+        raise ArgumentError, 'At most one of the options :weights and ' +
+          ':substitutions may be specified.'
+      end
+
+      case options.keys.first
+        when :substitutions: subs = options[:substitutions]
+        when :weights:
+          weights = options[:weights]
+          subs = Hash.new do |hash, key|
+            if weights[key].nil?
+              hash[key] = nil
+            else
+              hash[key] = key * weights[key]
+            end
+          end
+        else raise ArgumentError, "Unrecognized option #{options.keys.first}."
+      end
+      Connection::SetSumOperand.new(@model, self, subs)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in connection 
+  # constraints.
+  module Connection #:nodoc:
+    class SetMinOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, set_op)
+        super model
+        @set = set_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        set = @set.to_set_var
+        if constrain
+          int_operand.must_be.in set.upper_bound.min..set.lower_bound.min
+        end
+        
+        Gecode::Raw::min(@model.active_space, set.bind, 
+          int_operand.to_int_var.bind)
+      end
+    end
+    
+    class SetMaxOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, set_op)
+        super model
+        @set = set_op
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        set = @set.to_set_var
+        if constrain
+          int_operand.must_be.in set.upper_bound.min..set.lower_bound.min
+        end
+        
+        Gecode::Raw::max(@model.active_space, set.bind, 
+          int_operand.to_int_var.bind)
+      end
+    end
+    
+    class SetSumOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, set_op, subs)
+        super model
+        @set = set_op
+        @subs = subs
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        set = @set.to_set_var
+        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 }
+          int_operand.must_be.in min..max
+        end
+
+        Gecode::Raw::weights(@model.active_space, lub, substituted_lub, 
+          set.bind, int_operand.to_int_var.bind)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Gecode::Set
+  class SetConstraintReceiver
+    # Constrains the set operand to have a domain equal to +constant_set+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set+ must equal [1,2,5]
+    #   set.must == [1,2,5]
+    #   
+    #   # +set+ must not equal 1..67
+    #   set.must_not == 1..67
+    #   
+    #   # +set+ must equal the singleton set 0. The constraint is reified with
+    #   # the boolean operand +is_singleton_zero+.
+    #   set.must.equal(0, :reify => is_singleton_zero)
+    def ==(constant_set, options = {})
+      add_domain_constraint(:==, constant_set, options)
+    end
+
+    # Constrains the set operand to be a superset of +constant_set+.
+    #
+    # ==== Examples 
+    # 
+    #   # +set+ must be a superset of [1,2,5]
+    #   set.must_be.superset_of [1,2,5]
+    #   
+    #   # +set+ must be a superset of 1..67
+    #   set.must_be.superset_of 1..67
+    #   
+    #   # +set+ must not be a superset of [0].
+    #   set.must_not_be.superset_of 0
+    #   
+    #   # +set+ must be a superset of [1,3,5,7]. The constraint is reified with
+    #   # the boolean operand +bool+.
+    #   set.must_be.superset_of([1.3.5.7], :reify => bool) 
+    def superset(constant_set, options = {})
+      add_domain_constraint(:superset, constant_set, options)
+    end
+
+    # Constrains the set operand to be a subset of +constant_set+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set+ must be a subset of [1,2,5]
+    #   set.must_be.subset_of [1,2,5]
+    #   
+    #   # +set+ must be a subset of 1..67
+    #   set.must_be.subset_of 1..67
+    #   
+    #   # +set+ must not be a subset of [0].
+    #   set.must_not_be.subset_of 0
+    #   
+    #   # +set+ must be a subset of [1,3,5,7]. The constraint is reified with
+    #   # the boolean operand +bool+.
+    #   set.must_be.subset_of([1.3.5.7], :reify => bool) 
+    def subset(constant_set, options = {})
+      add_domain_constraint(:subset, constant_set, options)
+    end
+
+    # Constrains the set operand to be disjoint with +constant_set+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set+ must be disjoint with [1,2,5]
+    #   set.must_be.disjoint_with [1,2,5]
+    #   
+    #   # +set+ must be disjoint with 1..67
+    #   set.must_be.disjoint_with 1..67
+    #   
+    #   # +set+ must not be disjoint with [0].
+    #   set.must_not_be.disjoint_with 0
+    #   
+    #   # +set+ must be disjoint with [1,3,5,7]. The constraint is reified with
+    #   # the boolean operand +bool+.
+    #   set.must_be.disjoint_with([1.3.5.7], :reify => bool) 
+    def disjoint(constant_set, options = {})
+      add_domain_constraint(:disjoint, constant_set, options)
+    end
+
+    # Constrains the set operand to be the complement of +constant_set+.
+    #
+    # ==== Examples 
+    # 
+    #   # +set+ must be the complement of [1,2,5]
+    #   set.must_be.complement_of [1,2,5]
+    #   
+    #   # +set+ must be the complement of 1..67
+    #   set.must_be.complement_of 1..67
+    #   
+    #   # +set+ must not be the complement of [0].
+    #   set.must_not_be.complement_of 0
+    #   
+    #   # +set+ must be the complement of [1,3,5,7]. The constraint is 
+    #   # reified with the boolean operand +bool+.
+    #   set.must_be.complement_of([1.3.5.7], :reify => bool) 
+    def complement(constant_set, options = {})
+      add_domain_constraint(:complement, constant_set, options)
+    end
+
+    alias_set_methods
+    
+    private
+    
+    # Adds a domain constraint for the specified relation name, constant set
+    # and options.
+    def add_domain_constraint(relation_name, constant_set, options)
+      unless Gecode::Util.constant_set? constant_set
+        raise TypeError, "Expected constant set, got #{constant_set.class}."
+      end
+      @params[:rhs] = constant_set
+      @params[:relation] = relation_name
+      @params.update Gecode::Set::Util.decode_options(options)
+      if relation_name == :==
+        @model.add_constraint Domain::EqualityDomainConstraint.new(@model, 
+          @params)
+      else
+        @model.add_constraint Domain::DomainConstraint.new(@model, @params)
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in domain constraints.
+  module Domain #:nodoc:
+    class EqualityDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        var, domain, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
+          :negate)
+        if negate
+          rel_type = Gecode::Util::NEGATED_SET_RELATION_TYPES[:==]
+        else
+          rel_type = Gecode::Util::SET_RELATION_TYPES[:==]
+        end
+        
+        (params = []) << var.to_set_var.bind
+        params << rel_type
+        params << Gecode::Util.constant_set_to_params(domain)
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        Gecode::Raw::dom(@model.active_space, *params.flatten)
+      end
+    end
+  
+    class DomainConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        var, domain, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
+          :relation)
+        
+        (params = []) << var.to_set_var.bind
+        params << Gecode::Util::SET_RELATION_TYPES[relation]
+        params << Gecode::Util.constant_set_to_params(domain)
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        Gecode::Raw::dom(@model.active_space, *params.flatten)
+      end
+      negate_using_reification
+    end
+  end
+end