gecoder-with-gecode 0.8.3 → 0.9.0

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

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

@@ -0,0 +1,79 @@
+module Gecode::SetEnum
+  module SetEnumOperand
+    # 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(mod) #:nodoc:
+      mod.module_eval do
+        # Now we enter the module SetEnumOperands is mixed into.
+        class << self
+          alias_method :pre_selection_included, :included
+          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?('[]') and 
+                  not instance_methods.include?('pre_selection_access')
+                alias_method :pre_selection_access, :[]
+              end
+            
+              # Produces a SetOperand representing the i:th set
+              # operand in the enumeration, where i is the value of the
+              # int operand used as index. 
+              #
+              # A set can also be used as index, in which case a
+              # SelectedSetOperand is produced.
+              #
+              # ==== Examples 
+              # 
+              #   # The set operand at the +x+:th position in +set_enum+,
+              #   # where +x+ is a int operand.  
+              #   set_enum[x]
+              #
+              #   # The SelectedSetOperand representing sets at positions
+              #   # included in the value of +set+ in +set_enum+,
+              #   set_enum[set]
+              #
+              def [](*vars)
+                # Hook in an element constraint if a operand is used for array 
+                # access.
+                if vars.first.respond_to? :to_int_var
+                  Select::SelectSetOperand.new(
+                    model, self, vars.first)
+                elsif vars.first.respond_to? :to_set_var
+                  Gecode::SelectedSet::SelectedSetOperand.new(
+                    self, vars.first)
+                else
+                  if respond_to? :pre_selection_access
+                    pre_selection_access(*vars) 
+                  end
+                end
+              end
+            end
+            pre_selection_included(mod)
+          end
+        end
+      end
+    end
+  end
+
+  module Select #:nodoc:
+    class SelectSetOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, enum_op, position_int_op)
+        super model
+        @enum = enum_op
+        @position = position_int_op
+      end
+
+      def constrain_equal(set_operand, constrain, propagation_options)
+        enum = @enum.to_set_enum
+        if constrain
+          set_operand.must_be.subset_of enum.upper_bound_range
+        end
+
+        Gecode::Raw::selectSet(@model.active_space, enum.bind_array, 
+          @position.to_int_var.bind, set_operand.to_set_var.bind)
+      end
+    end
+  end 
+end

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

@@ -1,28 +1,78 @@
-module Gecode
-  module SetEnumMethods
-    include Gecode::Constraints::LeftHandSideMethods
-    
+# A module containing constraints that have enumerations of set operands as 
+# left hand side.
+module Gecode::SetEnum #:nodoc:
+  # A SetEnumOperand is a enumeration of SetOperand on which the
+  # constraints defined in SetEnumConstraintReceiver can be placed.
+  #
+  # Enumerations of set operands can be created either by using
+  # Gecode::Model#set_var_array and Gecode::Model#set_var_matrix, or
+  # by wrapping an existing enumeration containing SetOperand using
+  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # created, all respond to the properties defined by SetEnumOperand.
+  #
+  # ==== Examples 
+  #
+  # Produces an array of five set operands, with greatest lower bound
+  # {0} and least upper bound {0, 1, 2}, inside a problem formulation
+  # using Gecode::Model#set_var_array:
+  #
+  #   set_enum = set_var_array(5, 0, 1..2)
+  #
+  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # a SetEnumOperand from an existing enumeration containing the
+  # set operands +set_operand1+ and +set_operand2+:
+  #
+  #   set_enum = wrap_enum([set_operand1, set_operand2])
+  #   
+  #--
+  # Classes that mix in SetEnumOperand must define #model and
+  # #to_set_enum .
+  module SetEnumOperand
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::SetEnum::Dummy.instance_methods.include? method.to_s
+        # Delegate to the set enum.
+        to_set_enum.method(method).call(*args)
+      else
+        super
+      end
+    end
+
     private
-    
-    # Produces an expression for the lhs module.
-    def expression(params)
-      params.update(:lhs => self)
-      Constraints::SetEnum::Expression.new(@model, params)
+
+    def construct_receiver(params)
+      Gecode::SetEnum::SetEnumConstraintReceiver.new(@model, params)
     end
   end
-  
-  # A module containing constraints that have enumerations of set variables as 
-  # left hand side.
-  module Constraints::SetEnum
-    # Expressions with set enums as left hand sides.
-    class Expression < Gecode::Constraints::Expression
-      # Raises TypeError unless the left hand side is a set enum.
-      def initialize(model, params)
-        super
-        
-        unless params[:lhs].respond_to? :to_set_var_array
-          raise TypeError, 'Must have set enum as left hand side.'
-        end
+
+  # SetEnumConstraintReceiver contains all constraints that can be
+  # placed on a SetEnumOperand.
+  #
+  # Constraints are placed by calling SetEnumOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # SetEnumConstraintReceiver from which the desired constraint can be used.
+  #
+  # ==== Examples 
+  #
+  # Constrains +set_enum+ to channel +int_enum+ by using 
+  # SetEnumConstraintReceiver#channel:
+  #
+  #   set_enum.must.channel set_enum
+  #
+  # Constrains each pair of set operands in +set_enum+ to at most share
+  # one element. Also constrains each set to have size 17. Uses 
+  # SetEnumConstraintReceiver#at_most_share_one_element.
+  #
+  #   set_enum.must.at_most_share_one_element(:size => 17)
+  #
+  class SetEnumConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is a set enum operand.
+    def initialize(model, params) #:nodoc:
+      super
+      
+      unless params[:lhs].respond_to? :to_set_enum
+        raise TypeError, 'Must have set enum operand as left hand side.'
       end
     end
   end
@@ -30,5 +80,5 @@ end
 
 require 'gecoder/interface/constraints/set_enum/channel'
 require 'gecoder/interface/constraints/set_enum/distinct'
-require 'gecoder/interface/constraints/set_enum/selection'
+require 'gecoder/interface/constraints/set_enum/select'
 require 'gecoder/interface/constraints/set_enum/operation'