gecoder-with-gecode 0.8.3 → 0.9.0

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

@@ -1,7 +1,22 @@
-module Gecode::Constraints::Set
-  class Expression
-    # Adds a channel constraint on the set variable with the specified enum of 
-    # boolean variables.
+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 ' + 
@@ -11,43 +26,25 @@ module Gecode::Constraints::Set
         raise ArgumentError, 'The channel constraint does not support the ' + 
           'reification option.'
       end
-      unless bool_enum.respond_to? :to_bool_var_array
-        raise TypeError, 'Expected an enum of bool variables, ' + 
+      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::Constraints::Set::Util.decode_options(options)
+      @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 variable and a boolean enum.
+  # involving one set operand and a boolean enum.
   module Channel #:nodoc:
-    # Describes a channel constraint that "channels" a set variable and an
-    # enumerations of boolean variables. This constrains the set variable to
-    # include value i exactly when the variable 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 variables called +bools+ to at
-    # # least have the first and third variables 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
-    class ChannelConstraint < Gecode::Constraints::Constraint
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
       def post
         lhs, rhs = @params.values_at(:lhs, :rhs)
-        Gecode::Raw::channel(@model.active_space, rhs.to_bool_var_array, 
-          lhs.bind)
+        Gecode::Raw::channel(@model.active_space, rhs.to_bool_enum.bind_array, 
+          lhs.to_set_var.bind)
       end
     end
   end

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

@@ -1,193 +1,130 @@
-module Gecode
-  class FreeSetVar
-    # Starts a constraint on the minimum value of the set.
+module Gecode::Set
+  module SetOperand
+    # Produces an IntOperand representing the minimum of the set.
+    #
+    # ==== Examples 
+    #
+    #  # The minimum of +set+.
+    #  set.min
     def min
-      params = {:lhs => self}
-      Gecode::Constraints::Set::Connection::MinExpressionStub.new(@model, params)
+      Connection::SetMinOperand.new(@model, self)
     end
     
-    # Starts a constraint on the maximum value of the set.
+    # Produces an IntOperand representing the maximum of the set.
+    #
+    # ==== Examples 
+    #
+    #  # The maximum of +set+.
+    #  set.max
     def max
-      params = {:lhs => self}
-      Gecode::Constraints::Set::Connection::MaxExpressionStub.new(@model, params)
+      Connection::SetMaxOperand.new(@model, self)
     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.
+    # 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, '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
+        raise ArgumentError, 'At most one of the options :weights and ' +
+          ':substitutions may be specified.'
       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.'
+      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
-      
-      @params.update(:variables => variables)
-      @model.add_constraint Connection::IncludeConstraint.new(@model, @params)
+      Connection::SetSumOperand.new(@model, self, subs)
     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]
+    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
-          variable.must_be.in set.upper_bound.min..set.lower_bound.min
+          int_operand.must_be.in set.upper_bound.min..set.lower_bound.min
         end
         
-        Gecode::Raw::min(@model.active_space, set.bind, variable.bind)
+        Gecode::Raw::min(@model.active_space, set.bind, 
+          int_operand.to_int_var.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]
+    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
-          variable.must_be.in set.lower_bound.max..set.upper_bound.max
+          int_operand.must_be.in set.upper_bound.min..set.lower_bound.min
         end
         
-        Gecode::Raw::max(@model.active_space, set.bind, variable.bind)
+        Gecode::Raw::max(@model.active_space, set.bind, 
+          int_operand.to_int_var.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)
+    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] }
+        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
+          int_operand.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)
+          set.bind, int_operand.to_int_var.bind)
       end
     end
   end
-end
+end

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

@@ -1,13 +1,102 @@
-module Gecode::Constraints::Set
-  class Expression
-    Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |name, type|
-      module_eval <<-"end_code"
-        # Creates a domain constraint using the specified constant set.
-        def #{name}(constant_set, options = {})
-          add_domain_constraint(:#{name}, constant_set, options)
-        end
-      end_code
+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
@@ -15,12 +104,12 @@ module Gecode::Constraints::Set
     # Adds a domain constraint for the specified relation name, constant set
     # and options.
     def add_domain_constraint(relation_name, constant_set, options)
-      unless Gecode::Constraints::Util.constant_set? constant_set
+      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::Constraints::Set::Util.decode_options(options)
+      @params.update Gecode::Set::Util.decode_options(options)
       if relation_name == :==
         @model.add_constraint Domain::EqualityDomainConstraint.new(@model, 
           @params)
@@ -32,78 +121,36 @@ module Gecode::Constraints::Set
   
   # A module that gathers the classes and modules used in domain constraints.
   module Domain #:nodoc:
-    # Describes a domain constraint which constrains a set to be equal to a 
-    # 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 varaible +is_singleton_zero+.
-    #   set.must.equal(0, :reify => is_singleton_zero)
-    class EqualityDomainConstraint < Gecode::Constraints::ReifiableConstraint
+    class EqualityDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
         var, domain, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
           :negate)
         if negate
-          rel_type = Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES[:==]
+          rel_type = Gecode::Util::NEGATED_SET_RELATION_TYPES[:==]
         else
-          rel_type = Gecode::Constraints::Util::SET_RELATION_TYPES[:==]
+          rel_type = Gecode::Util::SET_RELATION_TYPES[:==]
         end
         
-        (params = []) << var.bind
+        (params = []) << var.to_set_var.bind
         params << rel_type
-        params << Gecode::Constraints::Util.constant_set_to_params(domain)
-        params << reif_var.bind if reif_var.respond_to? :bind
+        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
   
-    # Describes a domain constraint which constrains a set to have a specific
-    # relation to a constant set. A constant set may be specified in three ways
-    # 
-    # [Fixnum]                Represents a singleton set.
-    # [Range]                 Represents a set containing all elements in the 
-    #                         range. This represents the set more efficiently 
-    #                         than when another enumeration with the same 
-    #                         elements are used.
-    # [Enumeration of Fixnum] Represents a set containing the enumeration’s 
-    #                         elements.
-    #
-    # The relations allowed are the same as in 
-    # <tt>Set::Relation::RelationConstraint</tt>.
-    #
-    # == Examples
-    # 
-    #   # +set+ must be subset of [1,2,5]
-    #   set.must_be.subset_of [1,2,5]
-    #   
-    #   # +set+ must be disjoint with 1..67
-    #   set.must_be.disjoint_with 1..67
-    #   
-    #   # +set+ must not be a superset of [0].
-    #   set.must_not_be.superset_of 0
-    #   
-    #   # +set+ must be subset of [1,3,5,7]. The constraint is reified with
-    #   # the boolean varaible +only_constains_odd_values+.
-    #   set.must_be.subset_of([1.3.5.7], :reify => only_contains_odd_values) 
-    class DomainConstraint < Gecode::Constraints::ReifiableConstraint
+    class DomainConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
         var, domain, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
           :relation)
         
-        (params = []) << var.bind
-        params << Gecode::Constraints::Util::SET_RELATION_TYPES[relation]
-        params << Gecode::Constraints::Util.constant_set_to_params(domain)
-        params << reif_var.bind if reif_var.respond_to? :bind
+        (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
+end

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

@@ -0,0 +1,36 @@
+module Gecode::Set
+  class SetConstraintReceiver
+    # Constrains this set to include the values of +int_enum+.
+    # 
+    # The constraint has the side effect of sorting the integer operands in a 
+    # non-descending order. It does not support reification nor negation.
+    # 
+    # ==== Examples 
+    # 
+    #   # Constrain +set+ to include the values of all operands in 
+    #   # +int_enum+.
+    #   set.must.include int_enum 
+    def include(int_enum)
+      unless int_enum.respond_to? :to_int_enum
+        raise TypeError, "Expected int var enum, got #{int_enum.class}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated include is not ' + 
+          'implemented.'
+      end
+      
+      @params.update(:variables => int_enum)
+      @model.add_constraint Connection::IncludeConstraint.new(@model, @params)
+    end
+  end
+
+  module Connection #:nodoc:
+    class IncludeConstraint < Gecode::Constraint #:nodoc:
+      def post
+        set, variables = @params.values_at(:lhs, :variables)
+        Gecode::Raw::match(@model.active_space, set.to_set_var.bind, 
+                           variables.to_int_enum.bind_array)
+      end
+    end
+  end
+end