gecoder-with-gecode 0.7.1-mswin32

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

@@ -0,0 +1,72 @@
+module Gecode::IntEnumMethods
+  # Starts an arithmetic max constraint. This overrides the normal enum max, but
+  # that's not a problem since variables are not implemented to be comparable.
+  def max
+    return Gecode::Constraints::IntEnum::Arithmetic::MaxExpressionStub.new(
+      @model, :lhs => self)
+  end
+  
+  # Starts an arithmetic min constraint. This overrides the normal enum min, but
+  # that's not a problem since variables are not implemented to be comparable.
+  def min
+    return Gecode::Constraints::IntEnum::Arithmetic::MinExpressionStub.new(
+      @model, :lhs => self)
+  end
+end
+
+# A module that gathers the classes and modules used by arithmetic constraints.
+module Gecode::Constraints::IntEnum::Arithmetic #:nodoc:
+  # Describes a CompositeStub for the max constraint, which constrains the 
+  # maximum value of the integer variables in an enumeration.
+  # 
+  # == Example
+  # 
+  #   # The maximum must be positive.
+  #   int_enum.max.must > 0
+  #   
+  #   # The maximum must equal a integer variable +max+.
+  #   int_enum.max.must == max
+  #   
+  #   # The maximum must not be negative. The constraint is reified with the 
+  #   # boolean variable +is_negative+ and strength +domain+ is selected.
+  #   int_enum.max.must_not_be.less_than(0, :reify => is_negative, 
+  #     :strength => :domain)
+  class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params, constrain)
+      enum, strength = @params.values_at(:lhs, :strength)
+      if constrain
+        variable.must_be.in enum.domain_range
+      end
+      
+      Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
+    end
+  end
+  
+  # Describes a CompositeStub for the min constraint, which constrains the 
+  # minimum value of the integer variables in an enumeration.
+  # 
+  # == Example
+  # 
+  #   # The minimum must be positive.
+  #   int_enum.min.must > 0
+  #   
+  #   # The minimum must equal a integer variable +min+.
+  #   int_enum.min.must == min
+  #   
+  #   # The minimum must not be non-positive. The constraint is reified with the 
+  #   # boolean variable +is_positive+ and strength +domain+ is selected.
+  #   int_enum.min.must_not_be.less_or_equal(0, :reify => is_positive, 
+  #     :strength => :domain)
+  class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params, constrain)
+      enum, strength = @params.values_at(:lhs, :strength)
+      if constrain
+        variable.must_be.in enum.domain_range
+      end
+      
+      Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Adds a channel constraint on the variables in the enum with the specified
+    # other set or int enum.
+    def channel(enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      unless enum.respond_to?(:to_int_var_array) or 
+          enum.respond_to?(:to_set_var_array)
+        raise TypeError, "Expected int or set enum, got #{enum.class}."
+      end
+      
+      @params.update(Gecode::Constraints::Util.decode_options(options))
+      @params.update(:rhs => enum)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints.
+  module Channel #:nodoc:
+    # Describes a channel constraint which "channels" two enumerations of 
+    # integer variables or one enumeration of integer variables and one 
+    # enumeration of set variables. Channel constraints are used to give 
+    # access to multiple viewpoints when modelling. 
+    # 
+    # When used on two integer enumeration, the channel constraint can be 
+    # thought of as constraining the arrays to be each other's inverses. When 
+    # used with an enumeration of sets the i:th set includes the value of the
+    # j:th integer.  
+    # 
+    # Neither reification nor negation is supported. Selecting strength is only 
+    # supported when using the constraint between two integer enumerations, 
+    # it's not supported when a set enumeration is used.  
+    # 
+    # == Example
+    # 
+    # 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
+    # 
+    # == Example (sets)
+    # 
+    #   # +set_enum+ is constrained to channel +int_enum+.
+    #   int_enum.must.channel set_enum
+    # 
+    #   # This is another way of saying the above.
+    #   set_enum.must.channel int_enum
+    class ChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs, strength = @params.values_at(:lhs, :rhs, :strength)
+      
+        lhs = lhs.to_int_var_array
+        if rhs.respond_to? :to_int_var_array
+          # Int var array.
+          Gecode::Raw::channel(@model.active_space, lhs, rhs.to_int_var_array,
+            strength)
+        else
+          # Set var array, no strength.
+          Gecode::Raw::channel(@model.active_space, lhs, rhs.to_set_var_array)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Gecode
+  module IntEnumMethods
+    # Specifies that a specific element should be counted, starting a count
+    # constraint. The element can be either an int var or a fixnum.
+    def count(element)
+      unless element.kind_of?(FreeIntVar) or element.kind_of?(Fixnum)
+        raise TypeError, 'Elements used with count can not be of type ' + 
+          "#{element.class}."
+      end
+      params = {:lhs => self, :element => element}
+      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
+        Gecode::Constraints::IntEnum::Count::Expression.new(m, ps)
+      end
+    end
+  end
+end
+
+# A module that gathers the classes and modules used in count constraints.
+module Gecode::Constraints::IntEnum::Count #:nodoc:
+  # Describes an expression 
+  class Expression < Gecode::Constraints::IntEnum::Expression #:nodoc:
+    def initialize(model, params)
+      super
+      unless params[:negate]
+        @method_relations = Gecode::Constraints::Util::RELATION_TYPES
+      else
+        @method_relations = Gecode::Constraints::Util::NEGATED_RELATION_TYPES
+      end
+    end
+    
+    Gecode::Constraints::Util::RELATION_TYPES.each_pair do |name, type|
+      class_eval <<-"end_code"
+        def #{name}(expression, options = {})
+          unless expression.kind_of?(Fixnum) or 
+              expression.kind_of?(Gecode::FreeIntVar)
+            raise TypeError, 'Invalid right hand side of count constraint: ' + 
+              "\#{expression.class}."
+          end
+        
+          relation = @method_relations[:#{name}]
+          @params.update(Gecode::Constraints::Util.decode_options(options))
+          @params.update(:rhs => expression, :relation_type => relation)
+          @model.add_constraint CountConstraint.new(@model, @params)
+        end
+      end_code
+    end
+    alias_comparison_methods
+  end
+  
+  # Describes a count constraint, which constrains the number of times a value
+  # (constant or a variable) may occurr in an enumeration of integer variable.
+  # 
+  # All relations available for +SimpleRelationConstraint+ can be used with
+  # count constraints. Negation and reification is supported.
+  # 
+  # == Examples
+  # 
+  #   # Constrain +int_enum+ to not contain 0 exactly once.
+  #   int_enum.count(0).must_not == 1
+  #   
+  #   # Constrain +int_enum+ to contain +x+ exactly +x_count+ times.
+  #   int_enum.count(x).must == x_count
+  #   
+  #   # Reifies the constraint that +int_enum+ has +x+ zeros with the boolean
+  #   # variable +has_x_zeros+ and selects the strength +domain+.
+  #   int_enum.count(0).must.equal(x, :reify => has_x_zeros, 
+  #     :strength => :domain)
+  class CountConstraint < Gecode::Constraints::ReifiableConstraint
+    def post
+      lhs, element, relation_type, rhs, strength, reif_var = 
+        @params.values_at(:lhs, :element, :relation_type, :rhs, :strength, 
+          :reif)
+      
+      # Bind variables if needed.
+      element = element.bind if element.respond_to? :bind
+      rhs = rhs.bind if rhs.respond_to? :bind
+      
+      # Post the constraint to gecode.
+      if reif_var.nil?
+        Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
+          element, relation_type, rhs, strength)
+      else
+        # We use a proxy int variable to get the reification.
+        proxy = @model.int_var(rhs.min..rhs.max)
+        rel = Gecode::Constraints::Util::RELATION_TYPES.invert[relation_type]
+        proxy.must.send(rel, @params[:rhs], :reify => reif_var)
+        Gecode::Raw::count(@model.active_space, lhs.to_int_var_array, 
+          element, Gecode::Raw::IRT_EQ, proxy.bind, strength)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Gecode
+  module IntEnumMethods
+    # Specifies offsets to be used with a distinct constraint. The offsets can
+    # be specified one by one or as an array of offsets.
+    def with_offsets(*offsets)
+      if offsets.kind_of? Enumerable
+        offsets = *offsets
+      end
+      params = {:lhs => self, :offsets => offsets}
+      
+      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
+        Gecode::Constraints::IntEnum::Expression.new(m, ps)
+      end
+    end
+  end
+end
+
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Posts a distinct constraint on the variables in the enum.
+    def distinct(options = {})
+      if @params[:negate]
+        # The best we could implement it as from here would be a bunch of 
+        # reified pairwise equality constraints. 
+        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
+          'implemented.'
+      end
+    
+      @model.add_constraint Distinct::DistinctConstraint.new(@model, 
+        @params.update(Gecode::Constraints::Util.decode_options(options)))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in distinct constraints.
+  module Distinct #:nodoc:
+    # Describes a distinct constraint, which constrains all integer variables 
+    # in an enumeration to be distinct (different). The constraint can also be
+    # used with constant offsets, so that the variables, with specified offsets
+    # added, must be distinct.
+    # 
+    # The constraint does not support negation nor reification.
+    # 
+    # == Examples
+    # 
+    #   # Constrains all variables in +int_enum+ to be assigned different 
+    #   # values.
+    #   int_enum.must_be.distinct
+    #   
+    #   # The same as above, but also selects that the strength +domain+ should
+    #   # be used.
+    #   int_enum.must_be.distinct(:strength => :domain)
+    #   
+    #   # Uses the offset to constrain that no number may be the previous number
+    #   # incremented by one.
+    #   numbers = int_var_array(8, 0..9)
+    #   numbers.with_offset((1..numbers.size).to_a.reverse).must_be.distinct
+    class DistinctConstraint < Gecode::Constraints::Constraint
+      def post
+        # Bind lhs.
+        @params[:lhs] = @params[:lhs].to_int_var_array
+        
+        # Fetch the parameters to Gecode.
+        params = @params.values_at(:offsets, :lhs, :strength)
+        params.delete_if{ |x| x.nil? }
+        Gecode::Raw::distinct(@model.active_space, *params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# A module that gathers the classes and modules used by element constraints.
+module Gecode::Constraints::IntEnum::Element #:nodoc:
+  # Describes a CompositeStub for the element constraint, which places a 
+  # constraint on a variable at the specified position in an enumeration of 
+  # integer variables. It's basically the array access of constraint 
+  # programming.
+  # 
+  # == Example
+  # 
+  #   # The variable at the +x+:th position in +int_enum+ must be larger than
+  #   # +y+.
+  #   int_enum[x].must > y
+  # 
+  #   # The price of +selected_item+ as described by +prices+ must not be 
+  #   # larger than 100.
+  #   prices = wrap_enum([500, 24, 4711, 412, 24])
+  #   prices[selected_item].must_not > 100
+  #   
+  #   # Reify the constraint that the +x+:th variable in +int_enum+ must be in 
+  #   # range 7..17 with the boolean variable +bool+ and select strength 
+  #   # +domain+.  
+  # 
+  #   int_enum[x].must_be.in(7..17, :reify => bool, :strength => :domain)
+  class ExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params, constrain)
+      enum, position, strength = @params.values_at(:lhs, :position, :strength)
+      if constrain
+        variable.must_be.in enum.domain_range
+      end
+      
+      # The enum can be a constant array.
+      enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
+      Gecode::Raw::element(@model.active_space, enum, 
+        position.bind, variable.bind, strength)
+    end
+  end
+  
+  # Methods needed to add support for element constraints to enums.
+  module AdditionalEnumMethods #:nodoc:
+    # This adds the adder for the methods in the modules including it. The 
+    # reason for doing it so indirect is that the first #[] won't be defined 
+    # before the module that this is mixed into is mixed into an enum.
+    def self.included(enum_mod)
+      enum_mod.module_eval do
+        # Now we enter the module AdditionalEnumMethods is mixed into.
+        class << self
+          alias_method :pre_element_included, :included
+          def included(mod)
+            mod.module_eval do
+              # Now we enter the module that the module possibly defining #[] 
+              # is mixed into.
+              if instance_methods.include? '[]'
+                alias_method :pre_element_access, :[]
+              end
+            
+              def [](*vars)
+                # Hook in an element constraint if a variable is used for array 
+                # access.
+                if vars.first.kind_of? Gecode::FreeIntVar
+                  params = {:lhs => self, :position => vars.first}
+                  return Gecode::Constraints::IntEnum::Element::ExpressionStub.new(
+                    @model, params)
+                else
+                  pre_element_access(*vars) if respond_to? :pre_element_access
+                end
+              end
+            end
+            pre_element_included(mod)
+          end
+        end
+      end
+    end
+  end
+end
+
+module Gecode::IntEnumMethods
+  include Gecode::Constraints::IntEnum::Element::AdditionalEnumMethods
+end
+
+module Gecode::FixnumEnumMethods
+  include Gecode::Constraints::IntEnum::Element::AdditionalEnumMethods
+end

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

@@ -0,0 +1,38 @@
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Posts an equality constraint on the variables in the enum.
+    def equal(options = {})
+      if @params[:negate]
+        # The best we could implement it as from here would be a bunch of 
+        # reified pairwise inequality constraints.
+        raise Gecode::MissingConstraintError, 'A negated equality is not ' + 
+          'implemented.'
+      end
+    
+      @model.add_constraint Equality::EqualityConstraint.new(@model, 
+        @params.update(Gecode::Constraints::Util.decode_options(options)))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in equality constraints.
+  module Equality #:nodoc:
+    # Describes an equality constraint, which constrains all variables in an
+    # integer enumeration to be equal. Neither negation nor reification is 
+    # supported.
+    # 
+    # == Example
+    # 
+    #   # Constrains all variables in +int_enum+ to be equal.
+    #   int_enum.must_be.equal
+    class EqualityConstraint < Gecode::Constraints::Constraint
+      def post
+        # Bind lhs.
+        @params[:lhs] = @params[:lhs].to_int_var_array
+        
+        # Fetch the parameters to Gecode.
+        params = @params.values_at(:lhs, :strength)
+        Gecode::Raw::eq(@model.active_space, *params)
+      end
+    end
+  end
+end