gecoder-with-gecode 0.7.1-mswin32

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

@@ -0,0 +1,29 @@
+module Gecode
+  class FreeBoolVar
+    # Creates a linear expression where the bool variables are summed.
+    def +(var)
+      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+        @model) + var
+    end
+    
+    alias_method :pre_linear_mult, :* if instance_methods.include? '*'
+
+    # Creates a linear expression where the bool variable is multiplied with 
+    # a constant integer.
+    def *(int)
+      if int.kind_of? Fixnum
+        Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+          @model) * int
+      else
+        pre_linear_mult(int) if respond_to? :pre_linear_mult
+      end
+    end
+    
+    # Creates a linear expression where the specified variable is subtracted 
+    # from this one.
+    def -(var)
+      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+        @model) - var
+    end
+  end
+end

data/lib/gecoder/interface/constraints/bool_enum/boolean.rb

@@ -0,0 +1,84 @@
+module Gecode
+  module BoolEnumMethods
+    # Produces an expression that can be handled as if it was a variable 
+    # representing the conjunction of all boolean variables in the enumeration.
+    def conjunction
+      return Gecode::Constraints::BoolEnum::ConjunctionStub.new(
+        @model, :lhs => self)
+    end
+    
+    # Produces an expression that can be handled as if it was a variable 
+    # representing the disjunction of all boolean variables in the enumeration.
+    def disjunction
+      return Gecode::Constraints::BoolEnum::DisjunctionStub.new(
+        @model, :lhs => self)
+    end
+  end
+  
+  # A module that gathers the classes and modules used by boolean enumeration 
+  # constraints.
+  module Constraints::BoolEnum
+    # Describes a CompositeStub for the conjunction constraint, which constrain
+    # the conjunction of all boolean variables in an enumeration.
+    # 
+    # == Example
+    # 
+    #   # The conjunction of all variables in +bool_enum+ must be true. I.e. all
+    #   # boolean variables must take the value true.
+    #   bool_enum.conjunction.must_be.true
+    #   
+    #   # The conjunction of all variables in +bool_enum+ must equal b1.
+    #   bool_enum.conjunction.must ==  b1
+    #   
+    #   # The conjunction of all variables in +bool_enum+ must not equal b1 and 
+    #   # b2. It's reified it with +bool+ and selects the strength +domain+.
+    #   bool_enum.conjunction.must_not.equal(b1 & b2, :reify => bool, 
+    #     :strength => :domain)
+    class ConjunctionStub < Gecode::Constraints::Bool::CompositeStub
+      def constrain_equal(variable, params, constrain)
+        enum, strength = @params.values_at(:lhs, :strength)
+        
+        @model.add_interaction do
+          if variable.respond_to? :bind
+            bound = variable.bind
+          else
+            bound = variable
+          end
+          Gecode::Raw::bool_and(@model.active_space, enum.to_bool_var_array, 
+            bound, strength)
+        end
+        return variable
+      end
+    end
+    
+    # Describes a CompositeStub for the disjunction constraint, which constrain
+    # the disjunction of all boolean variables in an enumeration.
+    # 
+    # == Example
+    # 
+    #   # The disjunction of all variables in +bool_enum+ must be true. I.e. at
+    #   # least one of the boolean variables must take the value true.
+    #   bool_enum.disjunction.must_be.true
+    #   
+    #   # The disjunction of all variables in +bool_enum+ must equal b1.
+    #   bool_enum.conjunction.must ==  b1
+    #   
+    #   # The disjunction of all variables in +bool_enum+ must not equal b1 and 
+    #   # b2. It's reified it with +bool+ and selects the strength +domain+.
+    #   bool_enum.disjunction.must_not.equal(b1 & b2, :reify => bool, 
+    #     :strength => :domain)
+    class DisjunctionStub < Gecode::Constraints::Bool::CompositeStub
+      def constrain_equal(variable, params, constrain)
+        enum, strength = @params.values_at(:lhs, :strength)
+        
+        if variable.respond_to? :bind
+          bound = variable.bind
+        else
+          bound = variable
+        end
+        Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
+          bound, strength)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/bool_enum_constraints.rb

@@ -0,0 +1,8 @@
+module Gecode  
+  # A module containing constraints that have enumerations of boolean variables 
+  # as left hand side.
+  module Constraints::BoolEnum
+  end
+end
+
+require 'gecoder/interface/constraints/bool_enum/boolean'

data/lib/gecoder/interface/constraints/bool_var_constraints.rb

@@ -0,0 +1,75 @@
+module Gecode
+  class FreeBoolVar
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::Bool::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have int variables as left hand side
+  # (but not enumerations).
+  module Constraints::Bool
+    # Describes a boolean expression.
+    class Expression < Gecode::Constraints::Expression #:nodoc:
+    end
+    
+    # A composite expression which is an bool expression with a left hand side 
+    # resulting from a previous constraint.
+    class CompositeExpression < Gecode::Constraints::CompositeExpression #:nodoc:
+      # The block given should take three parameters. The first is the variable 
+      # that should be the left hand side, if it's nil then a new one should be
+      # created. The second is the has of parameters. The block should return 
+      # the variable used as left hand side.
+      def initialize(model, params, &block)
+        super(Expression, Gecode::FreeBoolVar, lambda{ model.bool_var }, model,
+          params, &block)
+      end
+      
+      # Override to also deal with constant booleans.
+      def true(options = {})
+        # We don't need any additional constraints.
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @model.add_interaction do
+          @constrain_equal_proc.call(!@params[:negate], @params)
+        end
+      end
+      
+      # Override to also deal with constant booleans.
+      def false(options = {})
+        # We don't need any additional constraints.
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @model.add_interaction do
+          @constrain_equal_proc.call(@params[:negate], @params)
+        end
+      end
+    end
+    
+    # Describes a stub that produces an int variable, which can then be used 
+    # with the normal int variable constraints. An example would be the 
+    # conjunction constraint.
+    #
+    #   bools.conjunction.must == b1 | b2
+    #
+    # <tt>bools.conjunction</tt> produces a boolean variable which the 
+    # constraint <tt>.must == b1 | b2</tt> is then applied to. In the above 
+    # case two constraints (and one temporary variable) are required, but in 
+    # the case of equality only one constraint is required.
+    # 
+    # Whether a constraint involving a reification stub supports negation, 
+    # reification, strength options and so on depends on the constraint on the
+    # right hand side.
+    class CompositeStub < Gecode::Constraints::CompositeStub
+      def initialize(model, params)
+        super(CompositeExpression, model, params)
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/bool/boolean'
+require 'gecoder/interface/constraints/bool/linear'

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

@@ -0,0 +1,71 @@
+class Gecode::FreeIntVar
+  # Initiates an arithmetic absolute value constraint.
+  def abs
+    Gecode::Constraints::Int::Arithmetic::AbsExpressionStub.new(@model, 
+      :lhs => self)
+  end
+
+  alias_method :pre_arith_mult, :* if instance_methods.include? '*'
+  
+  # Begins a multiplication constraint involving the two int variable.
+  def *(var)
+    if var.kind_of? Gecode::FreeIntVar
+      Gecode::Constraints::Int::Arithmetic::MultExpressionStub.new(
+        @model, :lhs => self, :var => var)
+    else
+      pre_arith_mult(var) if respond_to? :pre_arith_mult
+    end
+  end
+end
+
+# A module that gathers the classes and modules used by arithmetic constraints.
+module Gecode::Constraints::Int::Arithmetic #:nodoc:
+  # Describes a CompositeStub for absolute value constraints, which constrain
+  # the absolute value of an integer variable.
+  # 
+  # == Examples
+  #   
+  #   # The absolute value of +x+ must be less than 2.
+  #   x.abs.must < 2
+  #   
+  #   # The absolute value of +x+ must be in the range 5..7, with +bool+ as 
+  #   # reification variable and +value+ as strength.
+  #   x.abs.must_be.in(5..7, :reify => bool, :strength => :value)
+  class AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params, constrain)
+      lhs, strength = @params.values_at(:lhs, :strength)
+      if constrain
+        bounds = [lhs.min.abs, lhs.max.abs]
+        variable.must_be.in bounds.min..bounds.max
+      end
+      
+      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
+    end
+  end
+  
+  # Describes a CompositeStub for multiplication constraint, which constrain
+  # the value of the multiplication of two variables.
+  # 
+  # == Examples
+  #   
+  #   # The value of +x*y+ must be equal to their sum.
+  #   (x*y).must == x + y
+  #   
+  #   # The valye of +x*y+ must be less than 17, with +bool+ as reification 
+  #   # variable and +domain+ as strength.
+  #   (x*y).must_be.less_than(17, :reify => bool, :strength => :domain)
+  class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params, constrain)
+      lhs, lhs2, strength = @params.values_at(:lhs, :var, :strength)
+      if constrain
+        a_min = lhs.min; a_max = lhs.max
+        b_min = lhs2.min; b_max = lhs2.max
+        products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
+        variable.must_be.in products.min..products.max
+      end
+
+      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
+        variable.bind, strength)
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Gecode::Constraints::Int
+  class Expression
+    # Creates a domain constraint using the specified domain.
+    def in(domain, options = {})
+      @params.update(Gecode::Constraints::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 variable must be 
+    # contained within a specified range of integers. Supports reification and
+    # negation.
+    # 
+    # == 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 but reifies the constraint with the boolean 
+    #   # variable +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in(-5...5, :reify => bool, :strength => :value)
+    class RangeDomainConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        var, domain, reif_var, strength = @params.values_at(:lhs, :domain, 
+          :reif, :strength)
+        (params = []) << var.bind
+        params << domain.first << domain.last
+        params << reif_var.bind if reif_var.respond_to? :bind
+        params << strength
+        Gecode::Raw::dom(@model.active_space, *params)
+      end
+      negate_using_reification
+    end
+    
+    # Enum domain constraints specify that an integer variable must be contained
+    # in an enumeration of integers. Supports reification and negation.
+    # 
+    # == Examples
+    # 
+    #   # +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 but reifies the constraint with the boolean 
+    #   # variable +bool+ and specified +value+ as strength.
+    #   x.must_not_be.in(-[5,6,7,17], :reify => bool, :strength => :value)
+    class EnumDomainConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        space = @model.active_space
+      
+        var, domain, reif_var, strength = @params.values_at(:lhs, :domain, 
+          :reif, :strength)
+        
+        (params = []) << var.bind
+        params << Gecode::Constraints::Util.constant_set_to_int_set(domain)
+        params << reif_var.bind if reif_var.respond_to? :bind
+        params << strength
+        Gecode::Raw::dom(space, *params)
+      end
+      negate_using_reification
+    end
+  end
+end

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

@@ -0,0 +1,295 @@
+module Gecode
+  class FreeIntVar
+    # Creates a linear expression where the int variables are summed.
+    def +(var)
+      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+        @model) + var
+    end
+    
+    alias_method :pre_linear_mult, :* if instance_methods.include? '*'
+
+    # Creates a linear expression where the int variable is multiplied with 
+    # a constant integer.
+    def *(int)
+      if int.kind_of? Fixnum
+        Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+          @model) * int
+      else
+        pre_linear_mult(int) if respond_to? :pre_linear_mult
+      end
+    end
+    
+    # Creates a linear expression where the specified variable is subtracted 
+    # from this one.
+    def -(var)
+      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
+        @model) - var
+    end
+  end
+  
+  module Constraints::Int
+    class Expression #:nodoc:
+      # Add some relation selection based on whether the expression is negated.
+      alias_method :pre_linear_initialize, :initialize
+      def initialize(model, params)
+        pre_linear_initialize(model, params)
+        unless params[:negate]
+          @method_relations = Constraints::Util::RELATION_TYPES
+        else
+          @method_relations = Constraints::Util::NEGATED_RELATION_TYPES
+        end
+      end
+      
+      # Define the relation methods.
+      Constraints::Util::RELATION_TYPES.each_key do |name|
+        module_eval <<-"end_code"
+          def #{name}(expression, options = {})
+            relation = @method_relations[:#{name}]
+            @params.update(
+              Gecode::Constraints::Util.decode_options(options))
+            if self.simple_expression? and simple_expression?(expression)
+              # A relation constraint is enough.
+              add_relation_constraint(relation, expression)
+            else
+              add_linear_constraint(relation, expression)
+            end
+          end
+        end_code
+      end
+      alias_comparison_methods
+      
+      protected
+      
+      # Checks whether the given expression is simple enough to be used in a 
+      # simple relation constraint. Returns true if it is, false otherwise. If
+      # no expression is given then the this expression's left hand side is 
+      # checked.
+      def simple_expression?(expression = nil)
+        if expression.nil?
+          simple_expression?(@params[:lhs])
+        else
+          expression.kind_of?(Gecode::FreeIntVar) or
+            expression.kind_of?(Gecode::FreeBoolVar) or
+            expression.kind_of?(Fixnum)
+        end
+      end
+      
+      private
+      
+      # Places the linear constraint corresponding to the specified (integer)
+      # relation type (as specified by Gecode) in relation to the specifed 
+      # expression.
+      # 
+      # Raises TypeError if the element is of a type that doesn't allow a 
+      # relation to be specified.
+      def add_linear_constraint(relation_type, right_hand_side)
+        # Bind parameters.
+        lhs = @params[:lhs]
+        if lhs.kind_of?(Gecode::FreeIntVar) or lhs.kind_of?(Gecode::FreeBoolVar)
+          lhs = lhs * 1 # Convert to Gecode::Raw::LinExp
+        end
+        if not (right_hand_side.respond_to? :to_minimodel_lin_exp or
+            right_hand_side.kind_of?(Gecode::FreeIntVar) or
+            right_hand_side.kind_of?(Gecode::FreeBoolVar) or  
+            right_hand_side.kind_of?(Fixnum))
+          raise TypeError, 'Invalid right hand side of linear equation.'
+        end
+        
+        @params.update(:relation_type => relation_type, :lhs => lhs, 
+          :rhs => right_hand_side)
+        @model.add_constraint Linear::LinearConstraint.new(@model, @params)
+      end
+      
+      # Places the relation constraint corresponding to the specified (integer)
+      # relation type (as specified by Gecode) in relation to the specifed 
+      # element.
+      def add_relation_constraint(relation_type, element)
+        @model.add_constraint Linear::SimpleRelationConstraint.new(@model, 
+          @params.update(:relation_type => relation_type, :element => element))
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in linear constraints.
+  module Constraints::Int::Linear #:nodoc:
+    # Linear constraints specify that an integer variable must have a linear 
+    # equation containing variables must hold. The same relations and options
+    # used in +SimpleRelationConstraint+ can also be used for linear 
+    # constraints.
+    # 
+    # Boolean variables can also be used instead of integer variables. In that
+    # case a boolean variable assigned true is equal to 1 and a boolean variable
+    # assigned false is equal to 0. There is one exception: boolean variables 
+    # can not be used alone as left hand side.
+    # 
+    # Do not mix boolean and integer variables. Even if possible it's not 
+    # supported, and might be removed in the future.
+    # 
+    # == Examples
+    # 
+    #   # The sum of the int variables +x+ and +y+ must equal +z+ + 3.
+    #   (x + y).must == z + 3
+    #   
+    #   # Another way of writing the above. 
+    #   z.must == x + y - 3
+    #   
+    #   # The inequality 10(x + y) > 3x must not hold. 
+    #   (x + y)*10.must_not > x*3
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # variable +bool+ and gives it propagation strength +domain+.
+    #   (x + y)*10.must_not_be.greater_than(x*3, :reify => bool, :strength => :domain)
+    class LinearConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        lhs, rhs, relation_type, reif_var, strength = @params.values_at(:lhs, 
+          :rhs, :relation_type, :reif, :strength)
+        reif_var = reif_var.bind if reif_var.respond_to? :bind
+        if rhs.respond_to? :to_minimodel_lin_exp
+          rhs = rhs.to_minimodel_lin_exp
+        elsif rhs.respond_to? :bind
+          rhs = rhs.bind * 1
+        end
+
+        final_exp = (lhs.to_minimodel_lin_exp - rhs)
+        if reif_var.nil?
+          final_exp.post(@model.active_space, relation_type, strength)
+        else
+          final_exp.post(@model.active_space, relation_type, reif_var)
+        end
+      end
+    end
+
+    # Simple relation constraints specify that an integer variable must have a
+    # specified relation to a constant integer or another integer variable. The 
+    # following relations are supported (the aliases of each relation are also 
+    # listed).
+    # 
+    # * <, lesser, lesser_than
+    # * >, greater, greater_than
+    # * >=, greater_or_equal, greater_than_or_equal_to
+    # * <=, less_or_equal, less_than_or_equal_to
+    # * ==, equal, equal_to
+    # 
+    # Each can be negated by using +must_not+ instead of +must+.
+    # 
+    # Two options (given as a hash) are available:
+    # 
+    # [strength] Specifies the propagation strength of the constraint. Must be
+    #            one of +value+, +bounds+, +domain+ and +default+. The
+    #            strength generally progresses as +value+ -> +bounds+ -> 
+    #            +domain+ (+value+ being the weakest, but usually cheapest, 
+    #            while +domain+ is the strongest but usually costly).
+    # [reify]    Specifies a boolean variable that should be used for 
+    #            reification (see +ReifiableConstraint+).
+    # 
+    # == Examples
+    # 
+    #   # Int variable +x+ must not equal 0.
+    #   x.must_not.equal(0)
+    #   
+    #   # Another way of writing the above. 
+    #   x.must_not == 0
+    #   
+    #   # +x+ must be strictly larger than +y+.
+    #   x.must > y
+    #   
+    #   # Specifies the above, but reifies the constraint with the boolean 
+    #   # variable +bool+.
+    #   x.must_be.greater_than(y, :reify => bool)
+    class SimpleRelationConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        # Fetch the parameters to Gecode.
+        lhs, relation, rhs, reif_var, strength = @params.values_at(:lhs, 
+          :relation_type, :element, :reif, :strength)
+          
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
+            strength)
+        else
+          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
+            reif_var.bind, strength)
+        end
+      end
+    end
+  
+    # Helper methods for linear expressions. Classes mixing in this module must
+    # have a method #model which gives the model the expression is operating in. 
+    module Helper #:nodoc:
+      include Gecode::Constraints::LeftHandSideMethods
+      
+      private
+    
+      OPERATION_TYPES = [:+, :-, :*]
+    
+      public
+    
+      # Define methods for the available operations.
+      OPERATION_TYPES.each do |name|
+        module_eval <<-"end_code"
+          def #{name}(expression)
+            unless expression.kind_of? ExpressionTree
+              expression = ExpressionNode.new(expression)
+            end
+            ExpressionTree.new(self, expression, :#{name})
+          end
+        end_code
+      end
+      
+      private
+      
+      # Produces an expression for the lhs module.
+      def expression(params)
+        params.update(:lhs => self)
+        Gecode::Constraints::Int::Expression.new(model, params)
+      end
+    end
+    
+    # Describes a binary tree of expression nodes which together form a linear 
+    # expression.
+    class ExpressionTree #:nodoc:
+      include Helper
+    
+      # Constructs a new expression with the specified variable
+      def initialize(left_node, right_node, operation)
+        @left = left_node
+        @right = right_node
+        @operation = operation
+      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
+      
+      # Fetches the space that the expression's variables is in.
+      def model
+        @left.model || @right.model
+      end
+    end
+    
+    # Describes a single node in a linear expression.
+    class ExpressionNode #:nodoc:
+      include Helper
+    
+      attr :model
+    
+      def initialize(value, model = nil)
+        @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? :bind
+          # Minimodel requires that we do this first.
+          expression = expression.bind * 1
+        end
+        expression
+      end
+    end
+  end
+end