gecoder-with-gecode 0.7.1-mswin32

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

@@ -0,0 +1,109 @@
+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
+    end
+    alias_set_methods
+    
+    private
+    
+    # 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
+        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)
+      if relation_name == :==
+        @model.add_constraint Domain::EqualityDomainConstraint.new(@model, 
+          @params)
+      else
+        @model.add_constraint Domain::DomainConstraint.new(@model, @params)
+      end
+    end
+  end
+  
+  # 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
+      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[:==]
+        else
+          rel_type = Gecode::Constraints::Util::SET_RELATION_TYPES[:==]
+        end
+        
+        (params = []) << var.bind
+        params << rel_type
+        params << Gecode::Constraints::Util.constant_set_to_params(domain)
+        params << reif_var.bind if reif_var.respond_to? :bind
+        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
+      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
+        Gecode::Raw::dom(@model.active_space, *params.flatten)
+      end
+      negate_using_reification
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+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
+
+          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
+    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
+    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
+      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
+      def post
+        op1, op2, operation, relation, rhs, negate = @params.values_at(:lhs, 
+          :op2, :operation, :relation, :rhs, :negate)
+
+        op1, op2, rhs = [op1, op2, rhs].map do |expression|
+          # The expressions can either be set variables or constant sets, 
+          # convert them appropriately.
+          if expression.respond_to? :bind
+            expression.bind
+          else
+            Gecode::Constraints::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,178 @@
+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)
+      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
+    end
+    alias_set_methods
+    
+    private
+    
+    # Adds a relation constraint for the specified relation name, set variable
+    # 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)
+      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:
+    # 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
+      def post
+        var, rhs, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
+          :negate)
+        if negate
+          rel_type = Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES[:==]
+        else
+          rel_type = Gecode::Constraints::Util::SET_RELATION_TYPES[:==]
+        end
+        
+        (params = []) << var.bind
+        params << rel_type
+        params << rhs.bind
+        params << reif_var.bind if reif_var.respond_to? :bind
+        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
+      def post
+        var, 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
+        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

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

@@ -0,0 +1,18 @@
+module Gecode::Constraints::SetEnum
+  class Expression
+    # Posts a channel constraint on the variables in the enum with the specified
+    # int enum.
+    def channel(enum)
+      unless enum.respond_to? :to_int_var_array
+        raise TypeError, "Expected integer variable enum, for #{enum.class}."
+      end
+      
+      # Just provide commutativity to the corresponding int enum constraint.
+      if @params[:negate]
+        enum.must_not.channel(@params[:lhs])
+      else
+        enum.must.channel(@params[:lhs])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Gecode::Constraints::SetEnum
+  class Expression
+    # Adds a distinct constraint on the sets in the enum. The "option" :size 
+    # must be specified, the sets will be constrained to that size.
+    def distinct(options = {})
+      unless options.has_key? :size
+        raise ArgumentError, 'Option :size has to be specified.'
+      end
+      unless options.size == 1
+        raise ArgumentError, 'Only the option :size is accepted, got ' + 
+          "#{options.keys.join(', ')}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
+          'implemented.'
+      end
+      
+      @model.add_constraint Distinct::DistinctConstraint.new(
+        @model, @params.update(options))
+    end
+    
+    # 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.
+    def at_most_share_one_element(options = {})
+      unless options.has_key? :size
+        raise ArgumentError, 'Option :size has to be specified.'
+      end
+      unless options.size == 1
+        raise ArgumentError, 'Only the option :size is accepted, got ' + 
+          "#{options.keys.join(', ')}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated atmost one ' + 
+          'constrain is not implemented.'
+      end
+      
+      @model.add_constraint Distinct::AtMostOneConstraint.new(
+        @model, @params.update(options))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in distinct constraints.
+  module Distinct #:nodoc:
+    # Describes a set distinct constraint, which constrains all set variables
+    # in the enumeration to be distinct and 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 4 and be different.
+    #   sets.must_be.distinct(:size => 4)
+    class DistinctConstraint < Gecode::Constraints::Constraint
+      def post
+        sets, size = @params.values_at(:lhs, :size)
+        Gecode::Raw::distinct(@model.active_space, sets.to_set_var_array, size)
+      end
+    end
+    
+    # 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
+      def post
+        sets, size = @params.values_at(:lhs, :size)
+        Gecode::Raw::atmostOne(@model.active_space, sets.to_set_var_array, size)
+      end
+    end
+  end
+end