gecoder 0.8.3 → 0.9.0

data/lib/gecoder/interface/constraints/set_elements/relation.rb

@@ -0,0 +1,116 @@
+module Gecode::SetElements
+  class SetElementsConstraintReceiver
+    # Constrains the set elements to equal +operand+ (either a
+    # constant integer or an integer operand).
+    #
+    # ==== Examples 
+    #   
+    #   # The elements of +set+ must equal +int+
+    #   set.elements.must == int
+    #
+    #   # The elements of +set+ must equal 17
+    #   set.elements.must == 17
+    def ==(operand, options = {})
+      comparison(:==, operand, options)
+    end
+
+    # Constrains the set elements to be strictly greater than
+    # +operand+ (either a constant integer or an integer operand).
+    #
+    # ==== Examples 
+    #   
+    #   # The elements of +set+ must be strictly greater than +int+
+    #   set.elements.must > int
+    #
+    #   # The elements of +set+ must be strictly greater than 17
+    #   set.elements.must > 17
+    def >(operand, options = {})
+      comparison(:>, operand, options)
+    end
+    
+    # Constrains the set elements to be greater than or equal to
+    # +operand+ (either a constant integer or an integer operand).
+    #
+    # ==== Examples 
+    #   
+    #   # The elements of +set+ must be greater than or equal to +int+
+    #   set.elements.must >= int
+    #
+    #   # The elements of +set+ must be greater than or equal to 17
+    #   set.elements.must >= 17
+    def >=(operand, options = {})
+      comparison(:>=, operand, options)
+    end
+    
+    # Constrains the set elements to be strictly less than
+    # +operand+ (either a constant integer or an integer operand).
+    #
+    # ==== Examples 
+    #   
+    #   # The elements of +set+ must be strictly less than +int+
+    #   set.elements.must < int
+    #
+    #   # The elements of +set+ must be strictly less than 17
+    #   set.elements.must < 17
+    def <(operand, options = {})
+      comparison(:<, operand, options)
+    end
+    
+    # Constrains the set elements to be less than or equal to
+    # +operand+ (either a constant integer or an integer operand).
+    #
+    # ==== Examples 
+    #   
+    #   # The elements of +set+ must be less than or equal to +int+
+    #   set.elements.must <= int
+    #
+    #   # The elements of +set+ must be less than or equal to 17
+    #   set.elements.must <= 17
+    def <=(operand, options = {})
+      comparison(:<=, operand, options)
+    end
+    
+    alias_comparison_methods
+    
+    private
+
+    # Helper for the comparison methods. The reason that they are not
+    # generated in a loop is that it would mess up the RDoc.
+    def comparison(name, operand, options)
+      unless operand.respond_to?(:to_int_var) or 
+          operand.kind_of?(Fixnum)
+        raise TypeError, "Expected int operand or integer, got " + 
+          "#{operand.class}."
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the elements ' + 
+          'relation constraint.'
+      end
+
+      unless @params[:negate]
+        relation_type = Gecode::Util::RELATION_TYPES[name]
+      else
+        relation_type = Gecode::Util::NEGATED_RELATION_TYPES[name]
+      end
+      @params.update Gecode::Set::Util.decode_options(options)
+      @model.add_constraint Relation::RelationConstraint.new(@model, 
+        @params.update(:relation_type => relation_type, :rhs => operand))
+    end
+  end
+
+  module Relation #:nodoc:
+    class RelationConstraint < Gecode::Constraint #:nodoc:
+      def post
+        set_elements, rhs, type = @params.values_at(:lhs, :rhs, :relation_type)
+        set = set_elements.to_set_elements
+        
+        if rhs.kind_of? Fixnum
+          # Use a proxy int variable to cover.
+          rhs = @model.int_var(rhs)
+        end
+        Gecode::Raw::rel(@model.active_space, set.to_set_var.bind, 
+          type, rhs.to_int_var.bind)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# A module containing constraints that have set.elements as left hand
+# side.
+module Gecode::SetElements #:nodoc:
+  # A SetElementsOperand is an uncommon operand that results from calling 
+  # SetOperand#elements. It facilitates placing the constraints defined
+  # in SetElementsConstraintReceiver
+  #
+  # ==== Examples 
+  #
+  # Producing a SetElementsOperand from +set_operand+:
+  #
+  #   set_operand.elements
+  #
+  class SetElementsOperand 
+    include Gecode::Operand 
+
+    # Constructs a new set elements operand +set+.
+    def initialize(set) #:nodoc:
+      unless set.respond_to? :to_set_var
+        raise TypeError, "Expected set operand, got #{set.class}."
+      end
+
+      @set = set
+    end
+
+    # Returns the set operand that makes up the set elements operand.
+    def to_set_elements #:nodoc:
+      return @set
+    end
+
+    def model #:nodoc:
+      @set.model
+    end
+
+    private
+
+    def construct_receiver(params)
+      SetElementsConstraintReceiver.new(model, params)
+    end
+  end
+
+  # SetElementsConstraintReceiver contains all constraints that can be
+  # placed on a SetElementsOperand.
+  #
+  # Constraints are placed by calling SetElementsOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # SetElementsConstraintReceiver from which the desired constraint can 
+  # be used.
+  #
+  # Each constraint accepts a number of options. See ConstraintReceiver
+  # for more information.
+  #
+  # ==== Examples 
+  #
+  # Constrains all elements in +set_operand+ to be strictly greater than 17
+  # using SetOperand#elements and SetElementsConstraintReceiver#>: 
+  #
+  #   set.elements.must > 17
+  #
+  # Constrains all elements in +set_operand+ to be strictly greater than
+  # +int_operand+ using SetOperand#elements and SetElementsConstraintReceiver#>:
+  #
+  #   set.elements.must > int_operand
+  #
+  # The same as above, but specifying that strength :domain should be 
+  # used and that the constraint should be reified with +bool_operand+:
+  #
+  #   set.elements.must_be.greater_than(int_operand, :strength => :domain, :reify => bool_operand)
+  #
+  class SetElementsConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is set elements operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_set_elements
+        raise TypeError, 'Must have set elements operand as left hand side.'
+      end
+    end
+  end
+end
+
+module Gecode::Set #:nodoc:
+  module SetOperand
+    # Produces a SetElementsOperand on which relation constraints can be placed that
+    # constrain all elements in the set.
+    #
+    # ==== Examples 
+    #
+    #   # The elements of +set+.
+    #   set.elements
+    def elements
+      Gecode::SetElements::SetElementsOperand.new(self)
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/set_elements/relation.rb'

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

@@ -1,10 +1,21 @@
-module Gecode::Constraints::SetEnum
-  class Expression
-    # Posts a channel constraint on the variables in the enum with the specified
-    # int enum.
+module Gecode::SetEnum
+  class SetEnumConstraintReceiver
+    # Constrains this set enum to channel +int_enum_operand+. The i:th set 
+    # in the enumeration of set operands is constrained to includes the value 
+    # of the j:th integer operand. 
+    #
+    # Neither reification nor negation is supported.
+    #
+    # ==== Examples 
+    # 
+    #   # +set_enum+ is constrained to channel +int_enum+.
+    #   int_enum.must.channel set_enum
+    # 
+    #   # This is another way of writing the above.
+    #   set_enum.must.channel int_enum
     def channel(enum, options = {})
-      unless enum.respond_to? :to_int_var_array
-        raise TypeError, "Expected integer variable enum, for #{enum.class}."
+      unless enum.respond_to? :to_int_enum
+        raise TypeError, "Expected integer enum, for #{enum.class}."
       end
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
@@ -15,35 +26,20 @@ module Gecode::Constraints::SetEnum
           'reification option.'
       end
       
-      @params.update(Gecode::Constraints::Set::Util.decode_options(options))
+      @params.update(Gecode::Set::Util.decode_options(options))
       @params.update(:rhs => enum)
-      @model.add_constraint Channel::IntChannelConstraint.new(@model, @params)
+      @model.add_constraint Channel::IntEnumChannelConstraint.new(@model, @params)
     end
   end
   
   # A module that gathers the classes and modules used in channel constraints.
   module Channel #:nodoc:
-    # Describes a channel constraint which "channels" one enumeration of 
-    # integer variables with one enumeration of set variables. The i:th set 
-    # in the enumeration of set variables is constrainde to includes the value 
-    # of the j:th integer variable. 
-    # 
-    # Neither reification nor negation is supported.
-    # 
-    # == Examples
-    # 
-    #   # +set_enum+ is constrained to channel +int_enum+.
-    #   int_enum.must.channel set_enum
-    # 
-    #   # This is another way of saying the above.
-    #   set_enum.must.channel int_enum
-    #
-    class IntChannelConstraint < Gecode::Constraints::Constraint
+    class IntEnumChannelConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, rhs = @params.values_at(:lhs, :rhs)
-        Gecode::Raw::channel(@model.active_space, rhs.to_int_var_array, 
-          lhs.to_set_var_array)
+        Gecode::Raw::channel(@model.active_space, rhs.to_int_enum.bind_array, 
+          lhs.to_set_enum.bind_array)
       end
     end
   end
-end
+end

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

@@ -1,12 +1,21 @@
-module Gecode::Constraints::SetEnum
-  class Expression
-    # Adds a constraint on the sets that specifies that they must have at most
-    # one element in common. The "option" :size must be specified, the sets 
-    # will be constrained to that size.
+module Gecode::SetEnum
+  class SetEnumConstraintReceiver
+    # Constrains all pairs of set operands in the enumeration to at
+    # most have one element in common and be of a specified size.
+    # Providing a size is not optional.
+    # 
+    # Neither negation nor reification is supported.
+    # 
+    # ==== Examples 
+    # 
+    #   # All set operands in +sets+ must have cardinality 17 and no pair may
+    #   # have more than one element in common.
+    #   sets.must.at_most_share_one_element(:size => 17)
     def at_most_share_one_element(options = {})
       unless options.has_key? :size
         raise ArgumentError, 'Option :size has to be specified.'
       end
+      # TODO can we use Set::Util::decode_options here instead?
       unless options.size == 1
         raise ArgumentError, 'Only the option :size is accepted, got ' + 
           "#{options.keys.join(', ')}."
@@ -23,22 +32,12 @@ module Gecode::Constraints::SetEnum
   
   # A module that gathers the classes and modules used in distinct constraints.
   module Distinct #:nodoc:
-    # Describes an at most one constraint, which constrains all pairs of set 
-    # variables in the enumeration to at most have one element in common and be 
-    # of a specified size. Providing a size is not optional.
-    # 
-    # Neither negation nor reification is supported.
-    # 
-    # == Examples
-    # 
-    #   # All set variables in +sets+ must have cardinality 17 and no pair may
-    #   # have more than one element in common.
-    #   sets.must.at_most_share_one_element(:size => 17)
-    class AtMostOneConstraint < Gecode::Constraints::Constraint
+    class AtMostOneConstraint < Gecode::Constraint #:nodoc:
       def post
         sets, size = @params.values_at(:lhs, :size)
-        Gecode::Raw::atmostOne(@model.active_space, sets.to_set_var_array, size)
+        Gecode::Raw::atmostOne(@model.active_space, 
+          sets.to_set_enum.bind_array, size)
       end
     end
   end
-end
+end

data/lib/gecoder/interface/constraints/set_enum/operation.rb

@@ -1,60 +1,69 @@
-module Gecode::SetEnumMethods
-  Gecode::Constraints::Util::SET_OPERATION_TYPES.each_pair do |name, type|
-    next if type == Gecode::Raw::SOT_MINUS # Does not support this constraint?
+module Gecode::SetEnum
+  module SetEnumOperand
+    # Produces a SetOperand representing the union of all sets in this
+    # enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The union of all sets in +set_enum+.
+    #   set_enum.union
+    def union
+      set_operation(:union)
+    end
     
-    module_eval <<-"end_code"
-      # Starts a constraint on the #{name} of the sets.
-      def #{name}
-        params = {:lhs => self, :operation => #{type}}
-        Gecode::Constraints::SetEnum::Operation::ExpressionStub.new(
-          @model, params)
-      end
-    end_code
+    # Produces a SetOperand representing the intersection of all sets in this
+    # enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The intersection of all sets in +set_enum+.
+    #   set_enum.intersection
+    def intersection
+      set_operation(:intersection)
+    end
+
+    # Produces a SetOperand representing the disjoint union of all sets 
+    # in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The disjoint union of all sets in +set_enum+.
+    #   set_enum.disjoint_union
+    def disjoint_union
+      set_operation(:disjoint_union)
+    end
+
+    private
+
+    # Produces the SetOperand resulting from +operator+ applied to this
+    # operand.
+    def set_operation(operator)
+      Operation::OperationSetOperand.new(model, self, operator)
+    end
   end
-end
 
-# A module that gathers the classes and modules used by operation constaints.
-module Gecode::Constraints::SetEnum::Operation #:nodoc:
-  # Describes a CompositeStub for the enumeration operation constraint, which 
-  # constrains the result of applying an operation between all set variables in 
-  # a set enumeration. 
-  # 
-  # The supported operations are:
-  # * union
-  # * disjoint_union
-  # * intersection
-  # * minus
-  # 
-  # == Example
-  # 
-  #   # The union of all set variables in +sets+ must be subset of 1..17.
-  #   sets.union.must_be.subset_of 1..17
-  #   
-  #   # The intersection of all set variables must equal [1,3,5].
-  #   sets.intersection.must == [1,3,5]
-  #   
-  #   # The union of all set variable must be a subset of the set variable
-  #   # +universe+.
-  #   sets.union.must_be.subset_of universe
-  #   
-  #   # The same as above, but reified with the boolean variable 
-  #   # +is_within_universe+. 
-  #   sets.union.must_be.subset_of(universe, :reify => is_within_universe)
-  class ExpressionStub < Gecode::Constraints::Set::CompositeStub
-    def constrain_equal(variable, params, constrain)
-      enum, operation = @params.values_at(:lhs, :operation)
-    
-      if constrain
-        if operation == Gecode::Raw::SOT_INTER or 
-            operation == Gecode::Raw::SOT_MINUS
-          variable.must_be.subset_of enum.first.upper_bound
-        else
-          variable.must_be.subset_of enum.upper_bound_range
+  # A module that gathers the classes and modules used in operation constraints.
+  module Operation #:nodoc:
+    class OperationSetOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, enum, operator)
+        super model
+        @enum = enum
+        @operator = operator
+      end
+
+      def constrain_equal(set_operand, constrain_domain, propagation_options)
+        operation = Gecode::Util::SET_OPERATION_TYPES[@operator]
+        if constrain_domain
+          if operation == Gecode::Raw::SOT_INTER
+            set_operand.must_be.subset_of @enum.first.upper_bound
+          else
+            set_operand.must_be.subset_of @enum.upper_bound_range
+          end
         end
+        
+        Gecode::Raw::rel(@model.active_space, operation, 
+          @enum.to_set_enum.bind_array, set_operand.to_set_var.bind)
       end
-      
-      Gecode::Raw::rel(@model.active_space, operation, enum.to_set_var_array,
-        variable.bind)
     end
   end
-end
+end