gecoder 0.8.3 → 0.9.0

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

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

@@ -1,132 +1,118 @@
-module Gecode
-  class FreeSetVar
-    Gecode::Constraints::Util::SET_OPERATION_TYPES.each_pair do |name, type|
-      module_eval <<-"end_code"
-        # Starts a constraint on this set #{name} the specified set.
-        def #{name}(operand)
-          unless operand.kind_of?(Gecode::FreeSetVar) or 
-              Gecode::Constraints::Util::constant_set?(operand)
-            raise TypeError, 'Expected set variable or constant set as ' + 
-              "operand, got \#{operand.class}."
-          end
+module Gecode::Set
+  module SetOperand
+    # Produces a new SetOperand representing the union between this operand 
+    # and +set_operand_or_constant_set+.
+    #
+    # ==== Examples 
+    #
+    #   # The union between +set1+ and +set2+.
+    #   set1.union set2
+    #
+    #   # The union between +set+ and {1, 3, 5}.
+    #   set.union [1,3,5]
+    def union(set_operand_or_constant_set)
+      set_operation(:union, set_operand_or_constant_set)
+    end
 
-          params = {:lhs => self, :op2 => operand, :operation => #{type}}
-          Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
-            Gecode::Constraints::Set::Operation::Expression.new(m, ps)
-          end
-        end
-      end_code
+    # Produces a new SetOperand representing the disjoint union between
+    # this operand and +set_operand_or_constant_set+. The disjoint union
+    # is the union of the disjoint parts of the sets.
+    #
+    # ==== Examples 
+    #
+    #   # The disjoint union between +set1+ and +set2+.
+    #   set1.disjoint_union set2
+    #
+    #   # The disjoint union between +set+ and {1, 3, 5}.
+    #   set.disjoint_union [1,3,5]
+    def disjoint_union(set_operand_or_constant_set)
+      set_operation(:disjoint_union, set_operand_or_constant_set)
     end
-  end
-  
-  module FixnumEnumMethods
-    Gecode::Constraints::Util::SET_OPERATION_TYPES.each_pair do |name, type|
-      module_eval <<-"end_code"
-        # Starts a constraint on this set union the specified set.
-        def #{name}(operand)
-          unless operand.kind_of?(Gecode::FreeSetVar) or 
-              Gecode::Constraints::Util::constant_set?(operand)
-            raise TypeError, 'Expected set variable or constant set as ' + 
-              "operand, got \#{operand.class}."
-          end
 
-          params = {:lhs => self, :op2 => operand, :operation => #{type}}
-          Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
-            Gecode::Constraints::Set::Operation::Expression.new(m, ps)
-          end
-        end
-      end_code
+    # Produces a new SetOperand representing the intersection between
+    # this operand and +set_operand_or_constant_set+. 
+    #
+    # ==== Examples 
+    #
+    #   # The intersection between +set1+ and +set2+.
+    #   set1.intersection set2
+    #
+    #   # The intersection between +set+ and {1, 3, 5}.
+    #   set.intersection [1,3,5]
+    def intersection(set_operand_or_constant_set)
+      set_operation(:intersection, set_operand_or_constant_set)
+    end
+
+    # Produces a new SetOperand representing this operand minus 
+    # +set_operand_or_constant_set+. 
+    #
+    # ==== Examples 
+    #
+    #   # +set1+ minus +set2+.
+    #   set1.minus set2
+    #
+    #   # +set+ minus {1, 3, 5}.
+    #   set.minus [1,3,5]
+    def minus(set_operand_or_constant_set)
+      set_operation(:minus, set_operand_or_constant_set)
+    end
+
+    private 
+
+    # Produces the SetOperand resulting from +operator+ applied to this
+    # operand and +operand2+.
+    def set_operation(operator, operand2)
+      unless operand2.respond_to? :to_set_var or 
+        Gecode::Util::constant_set?(operand2)
+        raise TypeError, 'Expected set operand or constant set as ' + 
+              "operand, got \#{operand2.class}."
+      end
+
+      return Operation::OperationSetOperand.new(model, self, operator, 
+        operand2)
     end
   end
-end
 
-module Gecode::Constraints::Set
   # A module that gathers the classes and modules used in operation constraints.
   module Operation #:nodoc:
-    # An expression with a set operand and two operands followed by must.
-    class Expression < Gecode::Constraints::Expression #:nodoc:
-      Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |name, type|
-        module_eval <<-"end_code"
-          # Creates an operation constraint using the specified expression.
-          def #{name}(expression)
-            if @params[:negate]
-              # We do not allow negation.
-              raise Gecode::MissingConstraintError, 'A negated set operation ' + 
-                'constraint is not implemented.'
-            end
-            unless expression.kind_of?(Gecode::FreeSetVar) or 
-                Gecode::Constraints::Util::constant_set?(expression)
-              raise TypeError, 'Expected set variable or constant set, got ' + 
-                "\#{expression.class}."
-            end
-            
-            @params[:rhs] = expression
-            @params[:relation] = #{type}
-            unless @params.values_at(:lhs, :op2, :rhs).any?{ |element| 
-                element.kind_of? Gecode::FreeSetVar}
-              # At least one variable must be involved in the constraint.
-              raise ArgumentError, 'At least one variable must be involved ' +
-                'in the constraint, but all given were constants.'
-            end
-            
-            @model.add_constraint OperationConstraint.new(@model, @params)
-          end
-        end_code
+    class OperationSetOperand < Gecode::Set::ShortCircuitRelationsOperand #:nodoc:
+      def initialize(model, op1, operator, op2)
+        super model
+        @op1 = op1
+        @op2 = op2
+        @operator = operator
+      end
+
+      def relation_constraint(relation, set_operand_or_constant_set, params)
+        relation_type = 
+          Gecode::Util::SET_RELATION_TYPES[relation]
+
+        operation = Gecode::Util::SET_OPERATION_TYPES[@operator]
+        params.update(:rhs => set_operand_or_constant_set, 
+          :relation_type => relation_type, :op1 => @op1, :op2 => @op2,
+          :operation => operation)
+        OperationConstraint.new(model, params)
       end
-      alias_set_methods
     end
     
-    # Describes an operation constraint, which constrains the result of an
-    # operation with two sets as operands. Either constant sets or set 
-    # variables may be used for the result and operands, with the exception of
-    # that all three may not be constant sets.
-    # 
-    # The typical form is
-    #   set_operand_1.<operation>(set_operand_2).must.<relation>(result_set)
-    # 
-    # The following operations are supported:
-    # 
-    # * union
-    # * disjoint_union
-    # * intersection
-    # * minus
-    # 
-    # The allowed relations are the same as for 
-    # <tt>Set::Relation::RelationConstraint</tt>.
-    # 
-    # Neither reification nor negation is supported.
-    # 
-    # == Examples
-    # 
-    #   # +set_1+ union +set_2+ must equal +set_3+.
-    #   set_1.union(set_2).must == set_3
-    #   
-    #   # +set_1+ intersection [3,5,6] must equal +set_3+.
-    #   set_1.intersection([3,5,6]).must == set_3
-    #   
-    #   # [0,1,2] minus +set_2+ must be superset of +set_3+.
-    #   wrap_enum([0,1,2]).minus(set_2).must_be.superset_of(set_3)
-    #   
-    #   # +set_1+ disjoint union with [0] must be subset of 0..17.
-    #   set_1.disjoint_union(0).must_be.subset_of 0..17
-    class OperationConstraint < Gecode::Constraints::Constraint
+    class OperationConstraint < Gecode::Constraint #:nodoc:
       def post
-        op1, op2, operation, relation, rhs, negate = @params.values_at(:lhs, 
-          :op2, :operation, :relation, :rhs, :negate)
+        op1, op2, operation, relation, rhs, negate = @params.values_at(:op1, 
+          :op2, :operation, :relation_type, :rhs, :negate)
 
         op1, op2, rhs = [op1, op2, rhs].map do |expression|
-          # The expressions can either be set variables or constant sets, 
+          # The expressions can either be set operands or constant sets, 
           # convert them appropriately.
-          if expression.respond_to? :bind
-            expression.bind
+          if expression.respond_to? :to_set_var
+            expression.to_set_var.bind
           else
-            Gecode::Constraints::Util::constant_set_to_int_set(expression)
+            Gecode::Util::constant_set_to_int_set(expression)
           end
         end
 
-        Gecode::Raw::rel(@model.active_space, op1, operation, op2, relation, 
-          rhs)
+        Gecode::Raw::rel(@model.active_space, op1, operation, op2, 
+          relation, rhs)
       end
     end
   end
-end
+end

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

@@ -1,44 +1,110 @@
-module Gecode
-  class FreeSetVar
-    # Starts a constraint on all the elements of the set.
-    def elements
-      params = {:lhs => self}
-      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
-        Gecode::Constraints::Set::Relation::ElementExpression.new(m, ps)
+module Gecode::Set
+  class SetConstraintReceiver
+    alias_method :pre_relation_equality, :==
+    # Constrains the set operand to equal +set_operand+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set1+ must equal +set2+
+    #   set1.must == set2
+    #   
+    #   # +set1+ must equal +set2+. Reify the constraint with the
+    #   # boolean operand +bool+.
+    #   set1.must.equal(set2, :reify => bool)
+    def ==(set_operand, options = {})
+      if set_operand.respond_to? :to_set_var
+        add_relation_constraint(:==, set_operand, options)
+      else
+        pre_relation_equality(set_operand, options)
       end
     end
-  end
-end
 
-module Gecode::Constraints::Set
-  class Expression
-    Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |name, type|
-      module_eval <<-"end_code"
-        # Wrap previous relation methods providing support for relation 
-        # constraints.
-        alias_method 'pre_relation_#{type}_method'.to_sym, :#{name}
-        
-        # Creates a relation constraint using the specified expression.
-        def #{name}(expression, options = {})
-          if expression.kind_of? Gecode::FreeSetVar
-            add_relation_constraint(:#{name}, expression, options)
-          else
-            # Send it on.
-            pre_relation_#{type}_method(expression, options)
-          end
-        end
-      end_code
+    alias_method :pre_relation_superset, :superset
+    # Constrains the set operand to be a superset of +set_operand+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set1+ must be a superset of +set2+
+    #   set1.must_be.superset_of set2
+    #   
+    #   # +set1+ must be a superset of +set2+. Reify the constraint 
+    #   # with the boolean operand +bool+.
+    #   set1.must_be.superset(set2, :reify => bool)
+    def superset(set_operand, options = {})
+      if set_operand.respond_to? :to_set_var
+        add_relation_constraint(:superset, set_operand, options)
+      else
+        pre_relation_superset(set_operand, options)
+      end
     end
+
+    alias_method :pre_relation_subset, :subset
+    # Constrains the set operand to be a subeset of +set_operand+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set1+ must be a subset of +set2+
+    #   set1.must_be.subset_of == set2
+    #   
+    #   # +set1+ must be a subset of +set2+. Reify the constraint 
+    #   # with the boolean operand +bool+.
+    #   set1.must_be.subset(set2, :reify => bool)
+    def subset(set_operand, options = {})
+      if set_operand.respond_to? :to_set_var
+        add_relation_constraint(:subset, set_operand, options)
+      else
+        pre_relation_subset(set_operand, options)
+      end
+    end
+
+    alias_method :pre_relation_disjoint, :disjoint
+    # Constrains the set operand to be disjoint with +set_operand+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set1+ must be disjoint with +set2+
+    #   set1.must_be.disjoint_with set2
+    #   
+    #   # +set1+ must be disjoint with +set2+. Reify the constraint 
+    #   # with the boolean operand +bool+.
+    #   set1.must_be.disjoint(set2, :reify => bool)
+    def disjoint(set_operand, options = {})
+      if set_operand.respond_to? :to_set_var
+        add_relation_constraint(:disjoint, set_operand, options)
+      else
+        pre_relation_disjoint(set_operand, options)
+      end
+    end
+
+    alias_method :pre_relation_complement, :complement
+    # Constrains the set operand to be the complement of +set_operand+.
+    # 
+    # ==== Examples 
+    # 
+    #   # +set1+ must be the complement of +set2+
+    #   set1.must_be.complement_of set2
+    #   
+    #   # +set1+ must be the complement of +set2+. Reify the constraint 
+    #   # with the boolean operand +bool+.
+    #   set1.must_be.complement(set2, :reify => bool)
+    def complement(set_operand, options = {})
+      if set_operand.respond_to? :to_set_var
+        add_relation_constraint(:complement, set_operand, options)
+      else
+        pre_relation_complement(set_operand, options)
+      end
+    end
+
     alias_set_methods
     
     private
     
-    # Adds a relation constraint for the specified relation name, set variable
-    # and options.
+    # Adds a relation constraint for the specified relation name, set
+    # operand and options.
     def add_relation_constraint(relation_name, set, options)
       @params[:rhs] = 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 Relation::EqualityRelationConstraint.new(@model, 
           @params)
@@ -50,129 +116,40 @@ module Gecode::Constraints::Set
   
   # A module that gathers the classes and modules used in relation constraints.
   module Relation #:nodoc:
-    # Describes a relation constraint which constrains a set variable to be 
-    # equal to another set variable. Equality may either be expressed as
-    # +==+, +equal+ or +equal_to+.
-    # 
-    # == Examples
-    # 
-    #   # +set_1+ must be equal to +set_2+
-    #   set_1.must == set_2
-    #   
-    #   # +set_1+ must not be equal to +set_2+
-    #   set_1.must_not == set_2
-    #   
-    #   # The same as above but reified with the boolean variable 
-    #   # +are_not_equal+.
-    #   set_1.must_not.equal(set_2, :reify => are_not_equal)
-    class EqualityRelationConstraint < Gecode::Constraints::ReifiableConstraint
+    class EqualityRelationConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
-        var, rhs, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
+        lhs, rhs, 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 = []) << lhs.to_set_var.bind
         params << rel_type
-        params << rhs.bind
-        params << reif_var.bind if reif_var.respond_to? :bind
+        params << rhs.to_set_var.bind
+        if reif_var.respond_to? :to_bool_var
+          params << reif_var.to_bool_var.bind 
+        end
         Gecode::Raw::rel(@model.active_space, *params)
       end
     end
   
-    # Describes a relation constraint which constrains a set variable to have
-    # a specified relation to another set variable. The allowed relations and
-    # their aliases are
-    # 
-    # * subset, subset_of
-    # * superset, superset_of
-    # * disjoint, disjoint_with
-    # * complement, complement_of
-    # 
-    # == Examples
-    # 
-    #   # +set_1+ must be subset of +set_2+
-    #   set_1.must_be.subset_of set_2
-    #   
-    #   # +set_1+ must not be superset of +set_2+
-    #   set_1.must_not_be.superset_of set_2
-    #   
-    #   # +set_1+ must be disjoint with +set_2+
-    #   set_1.must_be.disjoint set_2
-    #   
-    #   # The same as above but reified with the boolean variable 
-    #   # +are_disjoint+.
-    #   set_1.must_be.disjoint(set_2, :reify => are_disjoint)
-    class RelationConstraint < Gecode::Constraints::ReifiableConstraint
+    class RelationConstraint < Gecode::ReifiableConstraint #:nodoc:
       def post
-        var, rhs, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
+        lhs, rhs, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
           :relation)
         
-        (params = []) << var.bind
-        params << Gecode::Constraints::Util::SET_RELATION_TYPES[relation]
-        params << rhs.bind
-        params << reif_var.bind if reif_var.respond_to? :bind
+        (params = []) << lhs.to_set_var.bind
+        params << Gecode::Util::SET_RELATION_TYPES[relation]
+        params << rhs.to_set_var.bind
+        if reif_var.respond_to? :to_bool_var
+          params << reif_var.to_bool_var.bind 
+        end
         Gecode::Raw::rel(@model.active_space, *params)
       end
       negate_using_reification
     end
-    
-    # Describes an element relation constraint which constrains all elements in
-    # a set variable to satisfy an integer relation constraint. The relations
-    # supported are the same as in 
-    # <tt>Int::Linear::SimpleRelationConstraint</tt>.
-    # 
-    # Reification is not supported.
-    # 
-    # == Examples
-    # 
-    #   # All elements in +set+ must be larger than 5.
-    #   set.elements.must > 5
-    #   
-    #   # No element in +set+ may equal 0.
-    #   set.elements.must_not == 0
-    #   
-    #   # No element in +set+ may contain the value of the integer variable
-    #   # +forbidden_number+.
-    #   set.elements.must_not == forbidden_number
-    class ElementRelationConstraint < Gecode::Constraints::Constraint
-      def post
-        var, rhs, relation = @params.values_at(:lhs, :rhs, :relation)
-        
-        if @params[:negate]
-          type = Gecode::Constraints::Util::NEGATED_RELATION_TYPES[relation]
-        else
-          type = Gecode::Constraints::Util::RELATION_TYPES[relation]
-        end
-
-        if rhs.kind_of? Fixnum
-          # Use a proxy int variable to cover.
-          rhs = @model.int_var(rhs)
-        end
-        Gecode::Raw::rel(@model.active_space, var.bind, type, rhs.bind)
-      end
-    end
-    
-    # Describes an expression which starts with set.elements.must* .
-    class ElementExpression < Gecode::Constraints::Expression #:nodoc:
-      Gecode::Constraints::Util::RELATION_TYPES.each_key do |name|
-        module_eval <<-"end_code"
-          # Creates an elements constraint using the specified expression, which
-          # may be either a constant integer of variable.
-          def #{name}(expression)
-            unless expression.kind_of?(Fixnum) or 
-                expression.kind_of?(Gecode::FreeIntVar)
-              raise TypeError, "Invalid expression type \#{expression.class}."
-            end
-            @params.update(:rhs => expression, :relation => :#{name})
-            @model.add_constraint ElementRelationConstraint.new(@model, @params)
-          end
-        end_code
-      end
-      alias_comparison_methods
-    end
   end
-end
+end