gecoder 0.4.0 → 0.5.0

data/lib/gecoder/interface/constraints.rb

@@ -33,70 +33,6 @@ module Gecode
       end
     end
     
-    # Describes a constraint expressions. An expression is produced by calling
-    # some form of must on a left hand side. The expression waits for a right 
-    # hand side so that it can post the corresponding constraint.
-    class Expression
-      # Constructs a new expression with the specified parameters. The 
-      # parameters shoud at least contain the keys :lhs, and :negate.
-      #
-      # Raises ArgumentError if any of those keys are missing.
-      def initialize(model, params)
-        unless params.has_key?(:lhs) and params.has_key?(:negate)
-          raise ArgumentError, 'Expression requires at least :lhs, ' + 
-            "and :negate as parameter keys, got #{params.keys.join(', ')}."
-        end
-        
-        @model = model
-        @params = params
-      end
-      
-      private
-      
-      # Creates aliases for any defined comparison methods.
-      def self.alias_comparison_methods
-        Gecode::Constraints::Util::COMPARISON_ALIASES.each_pair do |orig, aliases|
-          if instance_methods.include?(orig.to_s)
-            aliases.each do |name|
-              alias_method(name, orig)
-            end
-          end
-        end
-      end
-    end
-    
-    # Describes a constraint expression that has yet to be completed. I.e. a
-    # form of must has not yet been called, but some method has been called to
-    # initiate the expression. An example is distinct with offsets:
-    #
-    #   enum.with_offsets(0..n).must_be.distinct
-    # 
-    # The call of with_offsets initiates the constraint as a stub, even though
-    # must has not yet been called.
-    class ExpressionStub
-      # Constructs a new expression with the specified parameters.
-      def initialize(model, params)
-        @model = model
-        @params = params
-      end
-    end
-    
-    # Base class for all constraints.
-    class Constraint
-      # Creates a constraint with the specified parameters, bound to the 
-      # specified model. 
-      def initialize(model, params)
-        @model = model
-        @params = params.clone
-      end
-      
-      # Posts the constraint, adding it to the model. This is an abstract 
-      # method and should be overridden by all sub-classes.
-      def post
-        raise NoMethodError, 'Abstract method has not been implemented.'
-      end
-    end
-  
     # A module that provides some utility-methods for constraints.
     module Util
       # Maps the name used in options to the value used in Gecode for 
@@ -115,7 +51,8 @@ module Gecode
         :<= => Gecode::Raw::IRT_LQ,
         :<  => Gecode::Raw::IRT_LE,
         :>= => Gecode::Raw::IRT_GQ,
-        :>  => Gecode::Raw::IRT_GR }
+        :>  => Gecode::Raw::IRT_GR
+      }
       # The same as above, but negated.
       NEGATED_RELATION_TYPES = {
         :== => Gecode::Raw::IRT_NQ,
@@ -125,6 +62,20 @@ module Gecode
         :>  => Gecode::Raw::IRT_LQ
       }
       
+      # Maps the names of the methods to the corresponding set relation type in 
+      # Gecode.
+      SET_RELATION_TYPES = { 
+        :==         => Gecode::Raw::SRT_EQ,
+        :superset   => Gecode::Raw::SRT_SUP,
+        :subset     => Gecode::Raw::SRT_SUB,
+        :disjoint   => Gecode::Raw::SRT_DISJ,
+        :complement => Gecode::Raw::SRT_CMPL
+      }
+      # The same as above, but negated.
+      NEGATED_SET_RELATION_TYPES = {
+        :== => Gecode::Raw::SRT_NQ
+      }
+      
       # Various method aliases for comparison methods. Maps the original 
       # (symbol) name to an array of aliases.
       COMPARISON_ALIASES = { 
@@ -134,6 +85,13 @@ module Gecode
         :<  => [:less, :less_than],
         :<= => [:less_or_equal, :less_than_or_equal_to]
       }
+      SET_ALIASES = { 
+        :==         => [:equal, :equal_to],
+        :superset   => [:superset_of],
+        :subset     => [:subset_of],
+        :disjoint   => [:disjoint_with],
+        :complement => [:complement_of]
+      }
       
       module_function
       
@@ -167,6 +125,210 @@ module Gecode
         end
         return {:strength => PROPAGATION_STRENGTHS[strength], :reif => reif_var}
       end
+      
+      # Converts the different ways to specify constant sets in the interface
+      # to the form that the set should be represented in Gecode (possibly 
+      # multiple paramters. The different forms accepted are:
+      # * Single instance of Fixnum (singleton set).
+      # * Range (set containing all numbers in range), treated differently from
+      #   other enumerations.
+      # * Enumeration of integers (set contaning all numbers in set).
+      def constant_set_to_params(constant_set)
+        if constant_set.kind_of? Range
+          return constant_set.first, constant_set.last
+        elsif constant_set.kind_of? Fixnum
+          return constant_set
+        else
+          constant_set = constant_set.to_a
+          unless constant_set.all?{ |e| e.kind_of? Fixnum }
+            raise TypeError, "Not a constant set: #{constant_set}."
+          end
+          return Gecode::Raw::IntSet.new(constant_set, constant_set.size)
+        end
+      end
+    end
+    
+    # Describes a constraint expressions. An expression is produced by calling
+    # some form of must on a left hand side. The expression waits for a right 
+    # hand side so that it can post the corresponding constraint.
+    class Expression
+      # Constructs a new expression with the specified parameters. The 
+      # parameters shoud at least contain the keys :lhs, and :negate.
+      #
+      # Raises ArgumentError if any of those keys are missing.
+      def initialize(model, params)
+        unless params.has_key?(:lhs) and params.has_key?(:negate)
+          raise ArgumentError, 'Expression requires at least :lhs, ' + 
+            "and :negate as parameter keys, got #{params.keys.join(', ')}."
+        end
+        
+        @model = model
+        @params = params
+      end
+      
+      private
+      
+      # Creates aliases for any defined comparison methods.
+      def self.alias_comparison_methods
+        Gecode::Constraints::Util::COMPARISON_ALIASES.each_pair do |orig, aliases|
+          if instance_methods.include?(orig.to_s)
+            aliases.each do |name|
+              alias_method(name, orig)
+            end
+          end
+        end
+      end
+      
+      # Creates aliases for any defined set methods.
+      def self.alias_set_methods
+        Gecode::Constraints::Util::SET_ALIASES.each_pair do |orig, aliases|
+          if instance_methods.include?(orig.to_s)
+            aliases.each do |name|
+              alias_method(name, orig)
+            end
+          end
+        end
+      end
+    end
+    
+    # A composite expression which is a expression with a left hand side 
+    # resulting from a previous constraint.
+    class CompositeExpression < Gecode::Constraints::Expression
+      # The expression class should be the class of the expression delegated to,
+      # the variable class the kind of single variable used in the expression.
+      # 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(expression_class, variable_class, model, params, &block)
+        super(model, params)
+        @expression_class = expression_class
+        @variable_class = variable_class
+        @proc = block
+      end
+      
+      # Delegate to an instance of the expression class when we get something 
+      # that we can't handle.
+      def method_missing(name, *args)
+        if @expression_class.instance_methods.include? name.to_s
+          options = {}
+          if args.size >= 2 and args[1].kind_of? Hash
+            options = args[1]
+          end
+          @params.update Gecode::Constraints::Util.decode_options(options.clone)
+          @params[:lhs] = @proc.call(nil, @params)
+          @expression_class.new(@model, @params).send(name, *args)
+        else
+          super
+        end
+      end
+      
+      def ==(expression, options = {})
+        if !@params[:negate] and options[:reify].nil? and 
+            expression.kind_of? @variable_class
+          # We don't need any additional constraints.
+          @params.update Gecode::Constraints::Util.decode_options(options)
+          @proc.call(expression, @params)
+        else
+          method_missing(:==, expression, options)
+        end
+      end
+      alias_comparison_methods
+    end
+    
+    # Describes a constraint expression that has yet to be completed. I.e. a
+    # form of must has not yet been called, but some method has been called to
+    # initiate the expression. An example is distinct with offsets:
+    #
+    #   enum.with_offsets(0..n).must_be.distinct
+    # 
+    # The call of with_offsets initiates the constraint as a stub, even though
+    # must has not yet been called.
+    class ExpressionStub
+      # Constructs a new expression with the specified parameters.
+      def initialize(model, params)
+        @model = model
+        @params = params
+      end
+    end
+    
+    # Describes an expression stub which includes left hand side methods and
+    # just sends models and parameters through a supplied block to construct the
+    # resulting expression.
+    class SimpleExpressionStub < ExpressionStub
+      include Gecode::Constraints::LeftHandSideMethods
+    
+      # The block provided is executed when the expression demanded by the left
+      # hand side methods is to be constructed. The block should take two 
+      # parameters: model and params (which have been updated with negate and
+      # so on). The block should return an expression.
+      def initialize(model, params, &block)
+        super(model, params)
+        @proc = block
+      end
+      
+      private
+      
+      # Produces an expression with offsets for the lhs module.
+      def expression(params)
+        @params.update(params)
+        @proc.call(@model, @params)
+      end
+    end
+    
+    # Describes a stub that produces a variable, which can then be used with 
+    # that variable's normalconstraints. An example with int variables would be 
+    # the element constraint.
+    #
+    #   int_enum[int_var].must > rhs
+    #
+    # The int_enum[int_var] part produces an int variable which the constraint
+    # ".must > rhs" 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.
+    class CompositeStub < Gecode::Constraints::ExpressionStub
+      include Gecode::Constraints::LeftHandSideMethods
+      
+      # The composite expression class should be the class that the stub uses
+      # when creating its expressions.
+      def initialize(composite_expression_class, model, params)
+        super(model, params)
+        @composite_class = composite_expression_class
+      end
+      
+      private
+      
+      # Constrains the result of the stub to be equal to the specified variable
+      # with the specified parameters. If the variable given is nil then a new
+      # variable should be created for the purpose and returned. This is an 
+      # abstract method and should be overridden by all sub-classes.
+      def constrain_equal(variable, params)
+        raise NoMethodError, 'Abstract method has not been implemented.'
+      end
+      
+      # Produces an expression with position for the lhs module.
+      def expression(params)
+        @params.update params
+        @composite_class.new(@model, @params) do |var, params|
+          constrain_equal(var, params)
+        end
+      end
+    end
+    
+    # Base class for all constraints.
+    class Constraint
+      # Creates a constraint with the specified parameters, bound to the 
+      # specified model. 
+      def initialize(model, params)
+        @model = model
+        @params = params.clone
+      end
+      
+      # Posts the constraint, adding it to the model. This is an abstract 
+      # method and should be overridden by all sub-classes.
+      def post
+        raise NoMethodError, 'Abstract method has not been implemented.'
+      end
     end
   end
 end
@@ -175,3 +337,5 @@ require 'gecoder/interface/constraints/reifiable_constraints'
 require 'gecoder/interface/constraints/int_var_constraints'
 require 'gecoder/interface/constraints/int_enum_constraints'
 require 'gecoder/interface/constraints/bool_var_constraints'
+require 'gecoder/interface/constraints/bool_enum_constraints'
+require 'gecoder/interface/constraints/set_var_constraints'

data/lib/gecoder/interface/enum_wrapper.rb

@@ -11,15 +11,19 @@ module Gecode
         raise ArgumentError, 'Enumerable must not be empty.'
       end
       
-      if elements.map{ |var| var.kind_of? FreeIntVar }.all?
+      if elements.all?{ |var| var.kind_of? FreeIntVar }
         class <<enum
           include Gecode::IntEnumMethods
         end
-      elsif elements.map{ |var| var.kind_of? FreeBoolVar }.all?
+      elsif elements.all?{ |var| var.kind_of? FreeBoolVar }
         class <<enum
           include Gecode::BoolEnumMethods
         end
-      elsif elements.map{ |var| var.kind_of? Fixnum }.all?
+      elsif elements.all?{ |var| var.kind_of? FreeSetVar }
+        class <<enum
+          include Gecode::SetEnumMethods
+        end
+      elsif elements.all?{ |var| var.kind_of? Fixnum }
         class <<enum
           include Gecode::FixnumEnumMethods
         end
@@ -48,10 +52,14 @@ module Gecode
   
     # Returns an int variable array with all the bound variables.
     def to_int_var_array
-      elements = to_a
-      arr = Gecode::Raw::IntVarArray.new(active_space, elements.size)
-      elements.each_with_index{ |var, index| arr[index] = var.bind }
-      return arr
+      space = @model.active_space
+      unless @bound_space == space
+        elements = to_a
+        @bound_arr = Gecode::Raw::IntVarArray.new(active_space, elements.size)
+        elements.each_with_index{ |var, index| @bound_arr[index] = var.bind }
+        @bound_space = space
+      end
+      return @bound_arr
     end
     alias_method :to_var_array, :to_int_var_array
     
@@ -76,14 +84,37 @@ module Gecode
   
     # Returns a bool variable array with all the bound variables.
     def to_bool_var_array
-      elements = to_a
-      arr = Gecode::Raw::BoolVarArray.new(active_space, elements.size)
-      elements.each_with_index{ |var, index| arr[index] = var.bind }
-      return arr
+      space = @model.active_space
+      unless @bound_space == space
+        elements = to_a
+        @bound_arr = Gecode::Raw::BoolVarArray.new(active_space, elements.size)
+        elements.each_with_index{ |var, index| @bound_arr[index] = var.bind }
+        @bound_space = space
+      end
+      return @bound_arr
     end
     alias_method :to_var_array, :to_bool_var_array
   end
   
+  # A module containing the methods needed by enumerations containing set
+  # variables. Requires that it's included in an enumerable.
+  module SetEnumMethods
+    include EnumMethods
+  
+    # Returns a set variable array with all the bound variables.
+    def to_set_var_array
+      space = @model.active_space
+      unless @bound_space == space
+        elements = to_a
+        @bound_arr = Gecode::Raw::SetVarArray.new(active_space, elements.size)
+        elements.each_with_index{ |var, index| @bound_arr[index] = var.bind }
+        @bound_space = space
+      end
+      return @bound_arr
+    end
+    alias_method :to_var_array, :to_set_var_array
+  end
+  
   # A module containing the methods needed by enumerations containing fixnums. 
   # Requires that it's included in an enumerable.
   module FixnumEnumMethods

data/lib/gecoder/interface/model.rb

@@ -72,6 +72,51 @@ module Gecode
       return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
+    # Creates a set variable with the specified domain for greatest lower bound
+    # and least upper bound (specified as either a range or enum). A range for
+    # the allowed cardinality of the set can also be specified, if none is 
+    # specified, or nil is given, then the default range (anything) will be 
+    # used. If only a single Fixnum is specified as cardinality_range then it's
+    # used as lower bound.
+    def set_var(glb_domain, lub_domain, cardinality_range = nil)
+      check_set_bounds(glb_domain, lub_domain)
+      
+      index = active_space.new_set_vars(glb_domain, lub_domain, 
+        to_set_cardinality_range(cardinality_range)).first
+      FreeSetVar.new(self, index)
+    end
+    
+    # Creates an array containing the specified number of set variables. The
+    # parameters beyond count are the same as for #set_var .
+    def set_var_array(count, glb_domain, lub_domain, cardinality_range = nil)
+      check_set_bounds(glb_domain, lub_domain)
+      
+      variables = []
+      active_space.new_set_vars(glb_domain, lub_domain, 
+          to_set_cardinality_range(cardinality_range), count).each do |index|
+        variables << FreeSetVar.new(self, index)
+      end
+      return wrap_enum(variables)
+    end
+    
+    # Creates a matrix containing the specified number of rows and columns 
+    # filled with set variables. The parameters beyond row and column counts are
+    # the same as for #set_var .
+    def set_var_matrix(row_count, col_count, glb_domain, lub_domain, 
+        cardinality_range = nil)
+      check_set_bounds(glb_domain, lub_domain)
+      
+      indices = active_space.new_set_vars(glb_domain, lub_domain, 
+        to_set_cardinality_range(cardinality_range), row_count*col_count)
+      rows = []
+      row_count.times do |i|
+        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
+          FreeSetVar.new(self, index)
+        end
+      end
+      return wrap_enum(Util::EnumMatrix.rows(rows, false))
+    end
+    
     # Retrieves the currently active space (the one which variables refer to).
     def active_space
       @active_space ||= base_space
@@ -121,6 +166,36 @@ module Gecode
       return min..max
     end
     
+    # Transforms the argument to a set cardinality range, returns nil if the
+    # default range should be used. If arg is a range then that's used, 
+    # otherwise if the argument is a fixnum it's used as lower bound.
+    def to_set_cardinality_range(arg)
+      if arg.kind_of? Fixnum
+        arg..Gecode::Raw::Limits::Set::CARD_MAX
+      else
+        arg
+      end
+    end
+    
+    # Checks whether the specified greatest lower bound is a subset of least 
+    # upper bound. Raises ArgumentError if that is not the case.
+    def check_set_bounds(glb, lub)
+      unless valid_set_bounds?(glb, lub)
+        raise ArgumentError, 
+          "Invalid set bounds: #{glb} is not a subset of #{lub}."
+      end
+    end
+    
+    # Returns whether the greatest lower bound is a subset of least upper 
+    # bound.
+    def valid_set_bounds?(glb, lub)
+      if glb.kind_of?(Range) and lub.kind_of?(Range)
+        glb.first >= lub.first and glb.last <= lub.last
+      else
+        (glb.to_a - lub.to_a).empty?
+      end
+    end
+    
     # Creates an integer variable from the specified index and domain. The 
     # domain can either be given as a range or as a number of elements.
     def construct_int_var(index, *domain_args)

data/lib/gecoder/interface/search.rb

@@ -1,13 +1,5 @@
 module Gecode
   class Model
-    private
-    
-    # Used during the search.
-    COPY_DIST = 16
-    ADAPTATION_DIST = 4 
-    
-    public
-
     # Finds the first solution to the modelled problem and updates the variables
     # to that solution. Returns the model if a solution was found, nil 
     # otherwise.
@@ -54,7 +46,10 @@ module Gecode
       constraints.clear # Empty the queue.
     
       stop = Gecode::Raw::Search::Stop.new
-      Gecode::Raw::DFS.new(active_space, COPY_DIST, ADAPTATION_DIST, stop)
+      Gecode::Raw::DFS.new(active_space, 
+        Gecode::Raw::Search::Config::MINIMAL_DISTANCE,
+        Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
+        stop)
     end
   end
 end

data/lib/gecoder/interface/variables.rb

@@ -46,9 +46,9 @@ module Gecode
       
       def inspect
         if assigned?
-          "#<#{bound_class} range: \#{val.to_s}>"
+          "#<\#{self.class} \#{domain}>"
         else
-          "#<#{bound_class} range: \#{min}..\#{max}>"
+          "#<\#{self.class} \#{domain}>"
         end
       end
     end_method_definitions
@@ -57,6 +57,40 @@ module Gecode
   
   # Int variables.
   FreeIntVar = FreeVar(Gecode::Raw::IntVar, :int_var)
+  class FreeIntVar
+    # Returns a string representation of the the range of the variable's domain.
+    def domain
+      if assigned?
+        "range: #{val.to_s}"
+      else
+        "range: #{min}..#{max}"
+      end
+    end
+  end
+  
   # Bool variables.
   FreeBoolVar = FreeVar(Gecode::Raw::BoolVar, :bool_var)
+  class FreeBoolVar
+    # Returns a string representation of the the variable's domain.
+    def domain
+      if assigned?
+        true?.to_s
+      else
+        'unassigned'
+      end
+    end
+  end
+  
+  # Set variables.
+  FreeSetVar = FreeVar(Gecode::Raw::SetVar, :set_var)
+  class FreeSetVar
+    # Returns a string representation of the the variable's domain.
+    def domain
+      if assigned?
+        "#{glb_min}..#{lub_min}"
+      else
+        "glb-range: #{glb_min}..#{glb_max}, lub-range: #{lub_min}..#{lub_max}"
+      end
+    end
+  end
 end

data/lib/gecoder/version.rb

@@ -1,4 +1,4 @@
 module GecodeR
   # A string representation of the Gecode/R version.
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/specs/bool_var.rb

@@ -17,4 +17,62 @@ describe Gecode::FreeBoolVar, '(not assigned)' do
   it 'should not be assigned' do
     @var.should_not be_assigned
   end
+  
+  it "should say that it's not assigned when inspecting" do
+    @var.inspect.should include('unassigned')
+  end
+end
+
+describe Gecode::FreeBoolVar, '(assigned true)' do
+  before do
+    model = Gecode::Model.new
+    @var = model.bool_var
+    @var.must_be.true
+    model.solve!
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should respond true to true?' do
+    @var.true?.should be_true
+  end
+  
+  it 'should not respond true to false?' do
+    @var.false?.should_not be_true
+  end
+  
+  it "should say that it's true when inspecting" do
+    @var.inspect.should include('true')
+  end
+end
+
+describe Gecode::FreeBoolVar, '(assigned false)' do
+  before do
+    model = Gecode::Model.new
+    @var = model.bool_var
+    @var.must_be.false
+    model.solve!
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should respond not true to true?' do
+    @var.true?.should_not be_true
+  end
+  
+  it 'should respond true to false?' do
+    @var.false?.should be_true
+  end
+  
+  it "should say that it's false when inspecting" do
+    @var.inspect.should include('false')
+  end
 end