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

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

@@ -0,0 +1,118 @@
+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
+
+    # 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
+
+    # 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
+
+  # A module that gathers the classes and modules used in operation constraints.
+  module Operation #:nodoc:
+    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
+    end
+    
+    class OperationConstraint < Gecode::Constraint #:nodoc:
+      def post
+        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 operands or constant sets, 
+          # convert them appropriately.
+          if expression.respond_to? :to_set_var
+            expression.to_set_var.bind
+          else
+            Gecode::Util::constant_set_to_int_set(expression)
+          end
+        end
+
+        Gecode::Raw::rel(@model.active_space, op1, operation, op2, 
+          relation, rhs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+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
+
+    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
+    # operand and options.
+    def add_relation_constraint(relation_name, set, options)
+      @params[:rhs] = set
+      @params[:relation] = relation_name
+      @params.update Gecode::Set::Util.decode_options(options)
+      if relation_name == :==
+        @model.add_constraint Relation::EqualityRelationConstraint.new(@model, 
+          @params)
+      else
+        @model.add_constraint Relation::RelationConstraint.new(@model, @params)
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in relation constraints.
+  module Relation #:nodoc:
+    class EqualityRelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        lhs, rhs, 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 = []) << lhs.to_set_var.bind
+        params << rel_type
+        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
+  
+    class RelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        lhs, rhs, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
+          :relation)
+        
+        (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
+  end
+end

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'