gecoder 0.3.0 → 0.4.0

data/CHANGES

@@ -1,9 +1,25 @@
+== Version 0.4.0
+This release adds most of the constraints supported by Gecode for integer
+variables.
+
+* [#11861] Fixed a bug stopping the creating of int variables with non-range domains.
+* Added domain constraints for int variables.
+* Added equality constraint for int enums.
+* Matrices of integer and boolean variables can now be created using Model#int_var_matrix Model#bool_var_matrix.
+* Added channel constraint for int enums.
+* Added element constraints (variable array access).
+* Added count constraints.
+* Added sortedness constraints.
+* Added arithmetic constraints (min, max, abs and variable multiplication).
+
 == Version 0.3.0
+This release fleshes out the existing constraints with things such as 
+reification and adds boolean variables and their basic constraints.
 
 * The constructor of Gecode::Model no longer has to be called by classes inheriting from it.
 * Added Model#reset! which resets a model after search.
 * Added Model#solution which passes the first solution to a block and returns the result of that block.
-* Added Model#each_soltion which iterates over each solution.
+* Added Model#each_solution which iterates over each solution.
 * Added boolean variables. They are created using Model#bool_var and Model#bool_var_array .
 * Added two options to constraints: propagation strength and reification variable.
 * Linear and simple relation constraints can now also be specified using #equal, #equal_to, #greater, #greater_than,... in addition to comparison operators.
@@ -13,7 +29,6 @@
 * Added syntactic sugar for combining reifiable constraints with | and &.
 
 == Version 0.2.0
-
 This is the first release of Gecode/R, a Ruby interface to Gecode.
 
 * Added support for finite domain integers.

data/README

@@ -25,4 +25,10 @@ instructions.
 === Building the gem
 
   rake gem
-  gem install pkg/gecoder-0.x.x.gem
+  gem install pkg/gecoder-0.x.x.gem
+
+== Running the tests
+
+  rake specs
+
+Requires RSpec (1.0.5, but other version should hopefully work).

data/Rakefile

@@ -4,3 +4,7 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 
 require 'tasks/all_tasks'
+task :default => [:verify_rcov]
+
+desc 'Performs the tasks necessary when releasing'
+task :release => [:publish_website, :publish_packages, :tag]

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

@@ -10,14 +10,11 @@ module Gecode
   end
   
   module Constraints::Bool
-    # Add some relation selection based on whether the expression is negated.
-    alias_method :pre_bool_rel_initialize, :initialize
     class Expression
       def ==(expression)
         add_boolean_constraint(expression)
       end
-      alias_method :equal, :==
-      alias_method :equal_to, :==
+      alias_comparison_methods
       
       def true
         # Bind parameters.

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

@@ -0,0 +1,77 @@
+class Gecode::FreeIntVar
+  # Initiates an arithmetic absolute value constraint.
+  def abs
+    Gecode::Constraints::Int::Arithmetic::AbsExpressionStub.new(@model, 
+      :lhs => self)
+  end
+  
+  # Creates a linear expression where the int variable is multiplied with 
+  # a constant integer.
+  alias_method :pre_arith_mult, :* if instance_methods.include? '*'
+  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 
+  # Describes an expression stub started with an integer variable followed by 
+  # #abs .
+  class AbsExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces a proxy expression for the lhs module.
+    def expression(params)
+      # We extract the integer and continue as if it had been specified as
+      # left hand side. This might be elegant, but it could get away with 
+      # fewer constraints at times (when only equality is used) and 
+      # propagation strength can't be specified. 
+      # TODO: cut down on the number of constraints when possible. See if 
+      # there's some neat way of getting the above remarks. 
+      
+      params.update(@params)
+      lhs = params[:lhs]
+      proxy = @model.int_var(lhs.min..lhs.max)
+      lhs = lhs.bind
+      
+      Gecode::Raw::abs(@model.active_space, lhs, proxy.bind, 
+        Gecode::Raw::ICL_DEF)
+      Gecode::Constraints::Int::Expression.new(@model, 
+        params.update(:lhs => proxy))
+    end
+  end
+  
+  # Describes an expression stub started with an integer variable followed by 
+  # #* .
+  class MultExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces a proxy expression for the lhs module.
+    def expression(params)
+      # We extract the integer and continue as if it had been specified as
+      # left hand side. This might be elegant, but it could get away with 
+      # fewer constraints at times (when only equality is used) and 
+      # propagation strength can't be specified. 
+      # TODO: cut down on the number of constraints when possible. See if 
+      # there's some neat way of getting the above remarks. 
+      
+      params.update(@params)
+      lhs, var = params.values_at(:lhs, :var)
+      proxy = @model.int_var(-(lhs.min*var.min).abs..(lhs.max*var.max).abs) # Sloppy
+      
+      Gecode::Raw::mult(@model.active_space, lhs.bind, var.bind, proxy.bind, 
+        Gecode::Raw::ICL_DEF)
+      Gecode::Constraints::Int::Expression.new(@model, 
+        params.update(:lhs => proxy))
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+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)
+      else
+        @model.add_constraint Domain::NonRangeDomainConstraint.new(@model, 
+          @params)
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in domain constraints.
+  module Domain
+    # Describes a range domain constraint.
+    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
+    
+    # Describes a non-range domain constraint.
+    class NonRangeDomainConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        space = @model.active_space
+      
+        var, domain, reif_var, strength = @params.values_at(:lhs, :domain, 
+          :reif, :strength)
+        domain = domain.to_a
+        
+        (params = []) << var.bind
+        params << Gecode::Raw::IntSet.new(domain, domain.size)
+        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

@@ -8,9 +8,14 @@ module Gecode
     
     # Creates a linear expression where the int variable is multiplied with 
     # a constant integer.
+    alias_method :pre_linear_mult, :* if instance_methods.include? '*'
     def *(int)
-      Gecode::Constraints::Int::Linear::ExpressionNode.new(self, 
-        @model) * 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 
@@ -23,55 +28,24 @@ module Gecode
   
   module Constraints::Int
     class Expression
-      private
-    
-      # Maps the names of the methods to the corresponding integer relation 
-      # type in Gecode.
-      RELATION_TYPES = { 
-        :== => Gecode::Raw::IRT_EQ,
-        :<= => Gecode::Raw::IRT_LQ,
-        :<  => Gecode::Raw::IRT_LE,
-        :>= => Gecode::Raw::IRT_GQ,
-        :>  => Gecode::Raw::IRT_GR }
-      # The same as above, but negated.
-      NEGATED_RELATION_TYPES = {
-        :== => Gecode::Raw::IRT_NQ,
-        :<= => Gecode::Raw::IRT_GR,
-        :<  => Gecode::Raw::IRT_GQ,
-        :>= => Gecode::Raw::IRT_LE,
-        :>  => Gecode::Raw::IRT_LQ
-      }
-      
-      # Various method aliases for the class. Maps the original name to an 
-      # array of aliases.
-      METHOD_ALIASES = { 
-        :== => [:equal, :equal_to],
-        :>  => [:greater, :greater_than],
-        :>= => [:greater_or_equal, :greater_than_or_equal_to],
-        :<  => [:less, :less_than],
-        :<= => [:less_or_equal, :less_than_or_equal_to]
-      }
-      
-      public
-    
       # 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 = RELATION_TYPES
+          @method_relations = Constraints::Util::RELATION_TYPES
         else
-          @method_relations = NEGATED_RELATION_TYPES
+          @method_relations = Constraints::Util::NEGATED_RELATION_TYPES
         end
       end
       
       # Define the relation methods.
-      RELATION_TYPES.each_key do |name|
+      Constraints::Util::RELATION_TYPES.each_key do |name|
         module_eval <<-"end_code"
           def #{name}(expression, options = {})
             relation = @method_relations[:#{name}]
             @params.update(
-              Gecode::Constraints::OptionUtil.decode_options(options))
+              Gecode::Constraints::Util.decode_options(options))
             if self.simple_expression? and simple_expression?(expression)
               # A relation constraint is enough.
               add_relation_constraint(relation, expression)
@@ -81,13 +55,7 @@ module Gecode
           end
         end_code
       end
-      
-      # Various aliases.
-      METHOD_ALIASES.each_pair do |orig, alias_names|
-        alias_names.each do |name|
-          alias_method name, orig
-        end
-      end
+      alias_comparison_methods
       
       protected
       

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 
+  # Describes an expression stub started with an int var enum following by #max.
+  class MaxExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      # We extract the integer and continue as if it had been specified as
+      # left hand side. This might be elegant, but it could get away with 
+      # fewer constraints at times (when only equality is used) and 
+      # propagation strength can't be specified. 
+      # TODO: cut down on the number of constraints when possible. See if 
+      # there's some neat way of getting the above remarks. 
+      
+      params.update(@params)
+      lhs = params[:lhs]
+      proxy = @model.int_var(lhs.domain_range)
+      lhs = lhs.to_int_var_array
+      
+      Gecode::Raw::max(@model.active_space, lhs, proxy.bind, 
+        Gecode::Raw::ICL_DEF)
+      Gecode::Constraints::Int::Expression.new(@model, 
+        params.update(:lhs => proxy))
+    end
+  end
+  
+  # Describes an expression stub started with an int var enum following by #min.
+  class MinExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      # We extract the integer and continue as if it had been specified as
+      # left hand side. This might be elegant, but it could get away with 
+      # fewer constraints at times (when only equality is used) and 
+      # propagation strength can't be specified. 
+      # TODO: cut down on the number of constraints when possible. See if 
+      # there's some neat way of getting the above remarks. 
+      
+      params.update(@params)
+      lhs = params[:lhs]
+      proxy = @model.int_var(lhs.domain_range)
+      lhs = lhs.to_int_var_array
+      
+      Gecode::Raw::min(@model.active_space, lhs, proxy.bind, 
+        Gecode::Raw::ICL_DEF)
+      Gecode::Constraints::Int::Expression.new(@model, 
+        params.update(:lhs => proxy))
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Posts a channel constraint on the variables in the enum with the specified
+    # other enum.
+    def channel(enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      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
+    # Describes a channel constraint.
+    class ChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs, strength = @params.values_at(:lhs, :rhs, :strength)
+      
+        # Bind both sides.
+        lhs = lhs.to_int_var_array
+        rhs = rhs.to_int_var_array
+        
+        Gecode::Raw::channel(@model.active_space, lhs, rhs, strength)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+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}
+      return Gecode::Constraints::IntEnum::Count::ExpressionStub.new(
+        @model, params)
+    end
+  end
+end
+
+# A module that gathers the classes and modules used in count constraints.
+module Gecode::Constraints::IntEnum::Count
+
+
+  # Describes an expression stub started with an int var enum followed by
+  # #count .
+  class ExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression with the element for the lhs module.
+    def expression(params)
+      params.update(@params)
+      Gecode::Constraints::IntEnum::Count::Expression.new(@model, params)
+    end
+  end
+  
+  # Describes an expression 
+  class Expression < Gecode::Constraints::IntEnum::Expression
+    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.
+  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

@@ -7,7 +7,7 @@ module Gecode
         offsets = *offsets
       end
       params = {:lhs => self, :offsets => offsets}
-      return Gecode::Constraints::IntEnum::Distinct::OffsetExpression.new(
+      return Gecode::Constraints::IntEnum::Distinct::OffsetExpressionStub.new(
         @model, params)
     end
   end
@@ -25,7 +25,7 @@ module Gecode::Constraints::IntEnum
       end
     
       @model.add_constraint Distinct::DistinctConstraint.new(@model, 
-        @params.update(Gecode::Constraints::OptionUtil.decode_options(options)))
+        @params.update(Gecode::Constraints::Util.decode_options(options)))
     end
   end
   
@@ -33,14 +33,9 @@ module Gecode::Constraints::IntEnum
   module Distinct
     # Describes an expression started with an int var enum following with
     # #with_offsets .
-    class OffsetExpression < Gecode::Constraints::IntEnum::Expression
+    class OffsetExpressionStub < Gecode::Constraints::ExpressionStub
       include Gecode::Constraints::LeftHandSideMethods
       
-      def initialize(model, params)
-        @model = model
-        @params = params
-      end
-      
       private
       
       # Produces an expression with offsets for the lhs module.

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

@@ -0,0 +1,75 @@
+# A module that gathers the classes and modules used by element constraints.
+module Gecode::Constraints::IntEnum::Element 
+  # Describes an expression stub started with an int var enum following with an 
+  # array access using an integer variables .
+  class ExpressionStub < Gecode::Constraints::ExpressionStub
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression with position for the lhs module.
+    def expression(params)
+      # We extract the integer and continue as if it had been specified as
+      # left hand side. This might be elegant, but it could get away with 
+      # fewer constraints at times (when only equality is used) and 
+      # propagation strength can't be specified. 
+      # TODO: cut down on the number of constraints when possible. See if 
+      # there's some neat way of getting the above remarks. 
+      
+      params.update(@params)
+      enum, position = params.values_at(:lhs, :position)
+      tmp = @model.int_var(enum.domain_range)
+      enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
+      
+      Gecode::Raw::element(@model.active_space, enum, 
+        position.bind, tmp.bind, Gecode::Raw::ICL_DEF)
+      Gecode::Constraints::Int::Expression.new(@model, 
+        params.update(:lhs => tmp))
+    end
+  end
+  
+  # Methods needed to add support for element constraints to enums.
+  module AdditionalEnumMethods
+    # 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,31 @@
+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
+    # Describes an equality constraint.
+    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