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

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

@@ -0,0 +1,80 @@
+module Gecode::Int
+  class IntConstraintReceiver
+    # Creates a domain constraint using the specified domain, specified
+    # as an enumeration of integers. The integer operand is constrained
+    # to take a value in the domain.  Domains should be specified as
+    # ranges if possible.
+    # 
+    # ==== Examples 
+    # 
+    #   # +x+ must be in the range 1..10
+    #   x.must_be.in 1..10
+    #   
+    #   # +x+ must not be in the range -5...5
+    #   x.must_not_be.in -5...5
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # operand +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in(-5...5, :reify => bool, :strength => :value)
+    #
+    #   # +x+ must be in the enumeration [3,5,7].
+    #   x.must_be.in [3,5,7]
+    #   
+    #   # +x+ must not be in the enumeration [5,6,7,17].
+    #   x.must_not_be.in [5,6,7,17]
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # operand +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in([5,6,7,17], :reify => bool, :strength => :value)
+    #
+    def in(domain, options = {})
+      @params.update(Gecode::Util.decode_options(options))
+      @params[:domain] = domain
+      if domain.kind_of? Range
+        @model.add_constraint Domain::RangeDomainConstraint.new(@model, @params)
+      elsif domain.kind_of?(Enumerable) and domain.all?{ |e| e.kind_of? Fixnum }
+        @model.add_constraint Domain::EnumDomainConstraint.new(@model, 
+          @params)
+      else
+        raise TypeError, "Expected integer enumerable, got #{domain.class}."
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in domain constraints.
+  module Domain #:nodoc:
+    # Range domain constraints specify that an integer operand must be 
+    # contained within a specified range of integers.
+    class RangeDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
+          
+        (params = []) << var.to_int_var.bind
+        last = domain.last
+        last -= 1 if domain.exclude_end?
+        params << domain.first << last
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        params.concat propagation_options
+        
+        Gecode::Raw::dom(@model.active_space, *params)
+      end
+      negate_using_reification
+    end
+    
+    # Enum domain constraints specify that an integer operand must be contained
+    # in an enumeration of integers.
+    class EnumDomainConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        var, domain, reif_var = @params.values_at(:lhs, :domain, :reif)
+        
+        (params = []) << var.to_int_var.bind
+        params << Gecode::Util.constant_set_to_int_set(domain)
+        params << reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        params.concat propagation_options
+        
+        Gecode::Raw::dom(@model.active_space, *params)
+      end
+      negate_using_reification
+    end
+  end
+end

data/lib/gecoder/interface/constraints/int/linear.rb

@@ -0,0 +1,143 @@
+module Gecode::Int
+  module IntOperand
+    # Produces a new IntOperand representing this operand plus 
+    # +int_operand_or_fixnum+.
+    #
+    # ==== Examples 
+    #
+    #   # +int1+ plus +int2+
+    #   int1 + int2
+    #
+    #   # +int+ plus 17
+    #   int + 17
+    def +(int_operand_or_fixnum)
+      int_linear_expression_operation(:+, int_operand_or_fixnum)
+    end
+    
+    # Produces a new IntOperand representing this operand minus 
+    # +int_operand_or_fixnum+. 
+    #
+    # ==== Examples 
+    #
+    #   # +int1+ minus +int2+
+    #   int1 - int2
+    #
+    #   # +int+ minus 17
+    #   int - 17
+    def -(int_operand_or_fixnum)
+      int_linear_expression_operation(:-, int_operand_or_fixnum)
+    end
+
+    # Produces a new IntOperand representing this operand times a 
+    # constant. 
+    #
+    # ==== Examples 
+    #
+    #   # +int+ times 17
+    #   int * 17
+    def *(fixnum)
+      if fixnum.kind_of? Fixnum
+        int_linear_expression_operation(:*, fixnum)
+      else
+        raise TypeError, "Expected fixnum, got #{fixnum.class}."
+      end
+    end
+
+    private
+
+    # Performs the int linear expression operation +operator+ on self
+    # and +operand2+.
+    def int_linear_expression_operation(operator, operand2)
+      unless operand2.respond_to? :to_minimodel_lin_exp
+        operand2 = Linear::ExpressionNode.new operand2
+      end
+      operand1 = self
+      unless operand1.respond_to? :to_minimodel_lin_exp
+        operand1 = Linear::ExpressionNode.new(self, @model)
+      end
+      Linear::ExpressionTree.new(operand1, operand2, operator)
+    end
+  end
+
+  # A module that gathers the classes and modules used in linear constraints.
+  module Linear #:nodoc:
+    class LinearRelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        lhs, rhs, relation_type, reif_var = 
+          @params.values_at(:lhs, :rhs, :relation_type, :reif)
+        reif_var = reif_var.to_bool_var.bind if reif_var.respond_to? :to_bool_var
+        final_exp = (lhs.to_minimodel_lin_exp - rhs.to_minimodel_lin_exp)
+        if reif_var.nil?
+          final_exp.post(@model.active_space, relation_type, 
+            *propagation_options)
+        else
+          final_exp.post(@model.active_space, relation_type, reif_var, 
+            *propagation_options)
+        end
+      end
+    end
+
+    # Describes a binary tree of expression nodes which together form a linear 
+    # expression.
+    class ExpressionTree < Gecode::Int::ShortCircuitRelationsOperand #:nodoc:
+      attr :model
+
+      # Constructs a new expression with the specified operands.
+      def initialize(left_node, right_node, operation)
+        super(left_node.model || right_node.model)
+        @left = left_node
+        @right = right_node
+        @operation = operation
+        @model = @left.model || @right.model
+      end
+      
+      # Converts the linear expression to an instance of 
+      # Gecode::Raw::MiniModel::LinExpr
+      def to_minimodel_lin_exp
+        @left.to_minimodel_lin_exp.send(@operation, @right.to_minimodel_lin_exp)
+      end
+
+      def relation_constraint(relation, int_operand_or_fix, params)
+        unless params[:negate]
+          relation_type = 
+            Gecode::Util::RELATION_TYPES[relation]
+        else
+          relation_type = 
+            Gecode::Util::NEGATED_RELATION_TYPES[relation]
+        end
+
+        unless int_operand_or_fix.respond_to? :to_minimodel_lin_exp
+          int_operand_or_fix = Linear::ExpressionNode.new(int_operand_or_fix);
+        end
+
+        params.update(:lhs => self, :rhs => int_operand_or_fix, 
+          :relation_type => relation_type)
+        LinearRelationConstraint.new(model, params)
+      end
+    end
+    
+    # Describes a single node in a linear expression.
+    class ExpressionNode #:nodoc:
+      attr :model
+    
+      def initialize(value, model = nil)
+        unless value.respond_to?(:to_int_var) or value.kind_of?(Fixnum)
+          raise TypeError, 'Expected int operand or fixnum, ' + 
+            "got #{value.class}."
+        end
+        @value = value
+        @model = model
+      end
+      
+      # Converts the linear expression to an instance of 
+      # Gecode::Raw::MiniModel::LinExpr
+      def to_minimodel_lin_exp
+        expression = @value
+        if expression.respond_to? :to_int_var
+          expression = expression.to_int_var.bind * 1
+        end
+        expression
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Gecode::Int
+  class IntConstraintReceiver
+    # Constrains the integer operand to equal +int_operand_or_fixnum+.
+    # #equal and #equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must equal +int2+
+    #   int1.must == int2
+    #
+    #   # +int+ must equal 17
+    #   int.must == 17
+    #   
+    #   # +int1+ must equal +int2+. We reify the constraint with 
+    #   # +bool+ and select +domain+ as strength.
+    #   int1.must.equal(int2, :reify => bool, :strength => :domain)
+    def ==(int_operand_or_fixnum, options = {})
+      comparison(:==, int_operand_or_fixnum, options)
+    end
+
+    # Constrains the integer operand to be strictly greater than
+    # +int_operand_or_fixnum+. #greater and #greater_than are 
+    # aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be strictly greater than +int2+
+    #   int1.must > int2
+    #
+    #   # +int+ must be strictly greater than 17
+    #   int.must > 17
+    #   
+    #   # +int1+ must be strictly greater than +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must_be.greater_than(int2, :reify => bool, :strength => :domain)
+    def >(int_operand_or_fixnum, options = {})
+      comparison(:>, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be greater than or equal to
+    # +int_operand_or_fixnum+. #greater_or_equal and 
+    # #greater_than_or_equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be greater than or equal to +int2+
+    #   int1.must >= int2
+    #
+    #   # +int+ must be greater than or equal to 17
+    #   int.must >= 17
+    #   
+    #   # +int1+ must be greater than or equal to +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must.greater_or_equal(int2, :reify => bool, :strength => :domain)
+    def >=(int_operand_or_fixnum, options = {})
+      comparison(:>=, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be strictly less than
+    # +int_operand_or_fixnum+. #lesser and #lesser_than are 
+    # aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be strictly less than +int2+
+    #   int1.must < int2
+    #
+    #   # +int+ must be strictly less than 17
+    #   int.must < 17
+    #   
+    #   # +int1+ must be strictly less than +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must_be.less_than(int2, :reify => bool, :strength => :domain)
+    def <(int_operand_or_fixnum, options = {})
+      comparison(:<, int_operand_or_fixnum, options)
+    end
+    
+    # Constrains the integer operand to be less than or equal to
+    # +int_operand_or_fixnum+. #less_or_equal and 
+    # #less_than_or_equal_to are aliases of this method.
+    #
+    # ==== Examples 
+    #   
+    #   # +int1+ must be less than or equal to +int2+
+    #   int1.must <= int2
+    #
+    #   # +int+ must be less than or equal to 17
+    #   int.must <= 17
+    #   
+    #   # +int1+ must be less than or equal to +int2+. We reify the
+    #   # constraint with +bool+ and select +domain+ as strength.
+    #   int1.must.less_or_equal(int2, :reify => bool, :strength => :domain)
+    def <=(int_operand_or_fixnum, options = {})
+      comparison(:<=, int_operand_or_fixnum, 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, int_operand_or_fixnum, options)
+      unless int_operand_or_fixnum.respond_to?(:to_int_var) or 
+          int_operand_or_fixnum.kind_of?(Fixnum)
+        raise TypeError, "Expected int operand or integer, got " + 
+          "#{int_operand_or_fixnum.class}."
+      end
+
+      unless @params[:negate]
+        relation_type = Gecode::Util::RELATION_TYPES[name]
+      else
+        relation_type = Gecode::Util::NEGATED_RELATION_TYPES[name]
+      end
+      @params.update Gecode::Util.decode_options(options)
+      @model.add_constraint Relation::RelationConstraint.new(@model, 
+        @params.update(:relation_type => relation_type, 
+                       :rhs => int_operand_or_fixnum))
+    end
+  end
+
+  # A module that gathers the classes and modules used in relation constraints.
+  module Relation #:nodoc:
+    class RelationConstraint < Gecode::ReifiableConstraint #:nodoc:
+      def post
+        # Fetch the parameters to Gecode.
+        lhs, relation, rhs, reif_var = 
+          @params.values_at(:lhs, :relation_type, :rhs, :reif)
+          
+        rhs = rhs.to_int_var.bind if rhs.respond_to? :to_int_var
+        if reif_var.nil?
+          Gecode::Raw::rel(@model.active_space, lhs.to_int_var.bind, 
+            relation, rhs, *propagation_options)
+        else
+          Gecode::Raw::rel(@model.active_space, lhs.to_int_var.bind, 
+            relation, rhs, reif_var.to_bool_var.bind, *propagation_options)
+        end
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/int_enum/arithmetic.rb

@@ -0,0 +1,63 @@
+module Gecode::IntEnum
+  module IntEnumOperand
+    # Produces an IntOperand representing the maximum value of the 
+    # integer operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The maximum of +int_enum+.
+    #   int_enum.max
+    def max
+      Arithmetic::IntEnumMaxOperand.new(@model, self)
+    end
+    
+    # Produces an IntOperand representing the minimum value of the 
+    # integer operands in this enumeration.
+    #
+    # ==== Examples 
+    #
+    #   # The minimum of +int_enum+.
+    #   int_enum.min
+    def min
+      Arithmetic::IntEnumMinOperand.new(@model, self)
+    end
+  end
+
+  # A module that gathers the classes and modules used by arithmetic 
+  # constraints.
+  module Arithmetic #:nodoc:
+    class IntEnumMaxOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_enum)
+        super model
+        @int_enum = int_enum
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        enum = @int_enum.to_int_enum
+        if constrain
+          int_operand.must_be.in enum.domain_range
+        end
+        
+        Gecode::Raw::max(@model.active_space, enum.bind_array, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+    
+    class IntEnumMinOperand < Gecode::Int::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, int_enum)
+        super model
+        @int_enum = int_enum
+      end
+
+      def constrain_equal(int_operand, constrain, propagation_options)
+        enum = @int_enum.to_int_enum
+        if constrain
+          int_operand.must_be.in enum.domain_range
+        end
+        
+        Gecode::Raw::min(@model.active_space, enum.bind_array, 
+          int_operand.to_int_var.bind, *propagation_options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Gecode::IntEnum
+  class IntEnumConstraintReceiver
+    # Constrains this enumeration to "channel" +int_enum+.  Channel
+    # constraints are used to give access to multiple viewpoints when
+    # modelling. 
+    # 
+    # The channel constraint can be thought of as constraining the arrays to 
+    # be each other's inverses. I.e. if the i:th value in the first enumeration
+    # is j, then the j:th value in the second enumeration is constrained to be 
+    # i.
+    # 
+    # Neither reification nor negation is supported.
+    # 
+    # ==== Examples 
+    # 
+    # Lets say that we're modelling a sequence of numbers that must be distinct
+    # and that we want access to the following two view simultaneously.
+    # 
+    # === First view
+    # 
+    # The sequence is modelled as an array of integer variables where the first 
+    # variable holds the value of the first position in the sequence, the 
+    # second the value of the second position and so on.
+    # 
+    #   # n variables with values from 0 to n-1.
+    #   elements = int_var_array(n, 0...n)
+    #   elements.must_be.distinct
+    # 
+    # That way +elements+ will contain the actual sequence when the problem has 
+    # been solved.
+    # 
+    # === Second view
+    # 
+    # The sequence is modelled as the positions of each value in 0..(n-1) in 
+    # the sequence. That way the first variable would hold the positions of 0 
+    # in the sequence, the second variable would hold the positions of 1 in the 
+    # sequence and so on.
+    # 
+    #   positions = int_var_array(n, 0...n)
+    #   positions.must_be.distinct
+    # 
+    # === Connecting the views
+    #   
+    # In essence the relationship between the two arrays +elements+ and 
+    # +positions+ is that
+    # 
+    #   elements.map{ |e| e.val }[i] == positions.map{ |p| p.val }.index(i)
+    # 
+    # for all i in 0..(n-1). This relationship is enforced by the channel 
+    # constraint as follows. 
+    # 
+    #   elements.must.channel positions
+    # 
+    def channel(int_enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      unless int_enum.respond_to? :to_int_enum
+        raise TypeError, "Expected int enum, got #{int_enum.class}."
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraints does not support the ' +
+          'reification option.'
+      end
+      
+      @params.update(Gecode::Util.decode_options(options))
+      @params.update(:rhs => int_enum)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+    
+    # Provides commutativity with SetEnumConstraintReceiver#channel .
+    provide_commutativity(:channel){ |rhs, _| rhs.respond_to? :to_set_enum }
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints.
+  module Channel #:nodoc:
+    class ChannelConstraint < Gecode::Constraint #:nodoc:
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, lhs.to_int_enum.bind_array,
+          rhs.to_int_enum.bind_array, *propagation_options)
+      end
+    end
+  end
+end