gecoder 0.3.0 → 0.4.0

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

@@ -0,0 +1,104 @@
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Initiates a sort constraint. Beyond the common options the sort constraint
+    # can also take the following options:
+    # 
+    # [:as]     Defines a target (must be an int variable enumerable) that will
+    #           hold the sorted version of the original enumerable. The original
+    #           enumerable will not be affected (i.e. will not necessarily be 
+    #           sorted)
+    # [:order]  Sets an int variable enumerable that should be used to store the
+    #           order of the original enum's variables when sorted. The original
+    #           enumerable will not be affected (i.e. will not necessarily be 
+    #           sorted)
+    # 
+    # If neither of those options are specified then the original enumerable
+    # will be constrained to be sorted (otherwise not). Sort constraints with
+    # options do not allow negation.
+    def sorted(options = {})
+      # Extract and check options.
+      target = options.delete(:as)
+      order = options.delete(:order)
+      unless target.nil? or target.respond_to? :to_int_var_array
+        raise TypeError, 'Expected int var enum as :as, got ' + 
+          "#{target.class}."
+      end
+      unless order.nil? or order.respond_to? :to_int_var_array
+        raise TypeError, 'Expected int var enum as :order, got ' + 
+          "#{order.class}."
+      end
+      
+      # Extract standard options and convert to constraint.
+      @params.update(Gecode::Constraints::Util.decode_options(options))
+      if target.nil? and order.nil?
+        @model.add_constraint Sort::SortConstraint.new(@model, @params)
+      else
+        # Do not allow negation.
+        if @params[:negate]
+          raise Gecode::MissingConstraintError, 'A negated sort with options ' +
+            'is not implemented.'
+        end
+      
+        @params.update(:target => target, :order => order)
+        @model.add_constraint Sort::SortConstraintWithOptions.new(@model, 
+          @params)
+      end
+    end
+  end
+
+  # A module that gathers the classes and modules used in sort constraints.
+  module Sort
+    # Describes a sort constraint with target and order.
+    class SortConstraintWithOptions < Gecode::Constraints::Constraint
+      def post
+        if @params[:target].nil?
+          # We must have a target.
+          lhs = @params[:lhs]
+          @params[:target] = @model.int_var_array(lhs.size, lhs.domain_range)
+        end
+        
+        # Prepare the parameters.
+        params = @params.values_at(:lhs, :target, :order, :strength).map do |param| 
+          if param.respond_to? :to_int_var_array
+            param.to_int_var_array
+          else
+            param
+          end
+        end.delete_if{ |param| param.nil? }
+        # Post the constraint.
+        Gecode::Raw::sortedness(@model.active_space, *params)
+      end
+    end
+    
+    # Describes a sort constraint.
+    class SortConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        lhs, strength, reif_var = @params.values_at(:lhs, :strength, :reif)
+        using_reification = !reif_var.nil?
+        
+        # We translate the constraint into n-1 relation constraints.
+        options = {:strength => 
+          Gecode::Constraints::Util::PROPAGATION_STRENGTHS.invert[strength]}
+        if using_reification
+          reification_variables = @model.bool_var_array(lhs.size - 1)
+        end
+        (lhs.size - 1).times do |i|
+          first, second = lhs[i, 2]
+          rel_options = options.clone
+          if using_reification
+            # Reify each relation constraint and then bind them all together.
+            rel_options[:reify] = reification_variables[i]
+          end
+          first.must_be.less_than_or_equal_to(second, rel_options)
+        end
+        if using_reification
+          # TODO use the interface's all constraint when available.
+          # reification_variables.all.must == reif_var
+          Gecode::Raw::bool_and(@model.active_space, 
+            reification_variables.to_bool_var_array, reif_var.bind, strength) 
+        end
+      end
+      negate_using_reification
+    end
+  end
+end

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

@@ -29,3 +29,9 @@ module Gecode
 end
 
 require 'gecoder/interface/constraints/int_enum/distinct'
+require 'gecoder/interface/constraints/int_enum/equality'
+require 'gecoder/interface/constraints/int_enum/channel'
+require 'gecoder/interface/constraints/int_enum/element'
+require 'gecoder/interface/constraints/int_enum/count'
+require 'gecoder/interface/constraints/int_enum/sort'
+require 'gecoder/interface/constraints/int_enum/arithmetic'

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

@@ -20,3 +20,5 @@ module Gecode
 end
 
 require 'gecoder/interface/constraints/int/linear'
+require 'gecoder/interface/constraints/int/domain'
+require 'gecoder/interface/constraints/int/arithmetic'

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

@@ -53,5 +53,26 @@ module Gecode::Constraints
       end
       yield(con1_holds, con2_holds)
     end
+    
+    # If called the negation of the constraint will be handled using the 
+    # reification variable. This means that the post method (which has to be 
+    # defined prior to calling this method) doesn't have to bother about 
+    # negation.
+    def self.negate_using_reification
+      class_eval do
+        alias_method :post_without_negation, :post
+        
+        def post
+          if @params[:negate]
+            if @params[:reif].nil?
+              # Create a reification variable if none exists.
+              @params[:reif] = @model.bool_var
+            end
+            @params[:reif].must_be.false
+          end
+          post_without_negation
+        end
+      end
+    end
   end
 end

data/lib/gecoder/interface/constraints.rb

@@ -50,6 +50,35 @@ module Gecode
         @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.
@@ -68,11 +97,8 @@ module Gecode
       end
     end
   
-    # A module that provides some utility-methods for decoding options given to
-    # constraints.
-    module OptionUtil
-      private
-      
+    # A module that provides some utility-methods for constraints.
+    module Util
       # Maps the name used in options to the value used in Gecode for 
       # propagation strengths.
       PROPAGATION_STRENGTHS = {
@@ -82,7 +108,32 @@ module Gecode
         :domain   => Gecode::Raw::ICL_DOM
       }
       
-      public
+      # 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 comparison methods. Maps the original 
+      # (symbol) name to an array of aliases.
+      COMPARISON_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]
+      }
       
       module_function
       

data/lib/gecoder/interface/enum_matrix.rb

@@ -0,0 +1,64 @@
+require 'matrix'
+
+module Gecode::Util
+  # Methods that make a matrix an enumerable.
+  module MatrixEnumMethods
+    include Enumerable
+  
+    # Iterates over every element in the matrix.
+    def each(&block)
+      row_size.times do |i|
+        column_size.times do |j|
+          yield self[i,j]
+        end
+      end
+    end
+  end
+
+  # Extends Matrix so that it's an enumerable.
+  class EnumMatrix < Matrix
+    include MatrixEnumMethods
+    
+    def row(i)
+      wrap_if_wrapped make_vector_enumerable(super)
+    end
+    
+    def column(i)
+      wrap_if_wrapped make_vector_enumerable(super)
+    end
+    
+    def minor(*args)
+      matrix = super
+      class <<matrix
+        include MatrixEnumMethods
+      end
+      return wrap_if_wrapped(matrix)
+    end
+    
+    private
+    
+    # Makes the specified vector enumerable.
+    def make_vector_enumerable(vector)
+      class <<vector
+        include Enumerable
+  
+        # Iterates over every element in the matrix.
+        def each(&block)
+          size.times do |i|
+            yield self[i]
+          end
+        end
+      end
+      return vector
+    end
+    
+    # Wraps the specified enumerable if the matrix itself is already wrapped.
+    def wrap_if_wrapped(enum)
+      if respond_to? :model
+        model.wrap_enum(enum)
+      else
+        enum
+      end
+    end
+  end
+end

data/lib/gecoder/interface/enum_wrapper.rb

@@ -1,25 +1,28 @@
 module Gecode
   class Model
-    private
-    
     # Wraps a custom enumerable so that constraints can be specified using it.
     # The argument is altered and returned. 
     def wrap_enum(enum)
       unless enum.kind_of? Enumerable
         raise TypeError, 'Only enumerables can be wrapped.'
       end
-      if enum.empty?
+      elements = enum.to_a
+      if elements.empty?
         raise ArgumentError, 'Enumerable must not be empty.'
       end
       
-      if enum.first.kind_of? FreeIntVar
+      if elements.map{ |var| var.kind_of? FreeIntVar }.all?
         class <<enum
           include Gecode::IntEnumMethods
         end
-      elsif enum.first.kind_of? FreeBoolVar
+      elsif elements.map{ |var| var.kind_of? FreeBoolVar }.all?
         class <<enum
           include Gecode::BoolEnumMethods
         end
+      elsif elements.map{ |var| var.kind_of? Fixnum }.all?
+        class <<enum
+          include Gecode::FixnumEnumMethods
+        end
       else
         raise TypeError, "Enumerable doesn't contain variables #{enum.inspect}."
       end
@@ -51,6 +54,19 @@ module Gecode
       return arr
     end
     alias_method :to_var_array, :to_int_var_array
+    
+    # Returns the smallest range that contains the domains of all integer 
+    # variables involved.
+    def domain_range
+      inject(nil) do |range, var|
+        next var.min..var.max if range.nil?
+        min = var.min
+        max = var.max
+        range = min..range.last if min < range.first
+        range = range.first..max if max > range.last
+        range
+      end
+    end
   end
   
   # A module containing the methods needed by enumerations containing boolean
@@ -67,4 +83,16 @@ module Gecode
     end
     alias_method :to_var_array, :to_bool_var_array
   end
+  
+  # A module containing the methods needed by enumerations containing fixnums. 
+  # Requires that it's included in an enumerable.
+  module FixnumEnumMethods
+    include EnumMethods
+    
+    # Returns the smallest range that contains the domains of all integer 
+    # variables involved.
+    def domain_range
+      min..max
+    end
+  end
 end

data/lib/gecoder/interface/model.rb

@@ -26,6 +26,24 @@ module Gecode
       return wrap_enum(variables)
     end
     
+    # Creates a matrix containing the specified number rows and columns of 
+    # integer variables with the specified domain. The domain can either be a 
+    # range or a number of elements. 
+    def int_var_matrix(row_count, col_count, *domain_args)
+      # TODO: Maybe the custom domain should be specified as an array instead? 
+      
+      range = domain_range(*domain_args)
+      indices = active_space.new_int_vars(range.begin, range.end, 
+        row_count*col_count)
+      rows = []
+      row_count.times do |i|
+        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
+          construct_int_var(index, *domain_args)
+        end
+      end
+      return wrap_enum(Util::EnumMatrix.rows(rows, false))
+    end
+    
     # Creates a new boolean variable.
     def bool_var(*domain_args)
       index = active_space.new_bool_vars.first
@@ -41,6 +59,19 @@ module Gecode
       return wrap_enum(variables)
     end
     
+    # Creates a matrix containing the specified number rows and columns of 
+    # boolean variables.
+    def bool_var_matrix(row_count, col_count)
+      indices = active_space.new_bool_vars(row_count*col_count)
+      rows = []
+      row_count.times do |i|
+        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
+          FreeBoolVar.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
@@ -97,12 +128,11 @@ module Gecode
       
       if domain_args.size > 1
         # Place an additional domain constraint on the variable with the 
-        # arguments as domain.
-        # TODO: use the model's way of defining domain constraints when 
-        # available.
-        domain_set = Gecode::Raw::IntSet.new(domain_args, domain_args.size)
-        Gecode::Raw::dom(active_space, var.bind, domain_set, 
-          Gecode::Raw::ICL_DEF)
+        # arguments as domain. We post it directly since there's no reason not
+        # to and the user might otherwise get unexpected domains when inspecting
+        # the variable before solving.
+        constraint = var.must_be.in domain_args
+        @constraints.delete(constraint).post
       end
       return var
     end

data/lib/gecoder/interface.rb

@@ -1,5 +1,6 @@
 require 'gecoder/interface/binding_changes'
 require 'gecoder/interface/variables'
+require 'gecoder/interface/enum_matrix'
 require 'gecoder/interface/model'
 require 'gecoder/interface/search'
 require 'gecoder/interface/constraints'

data/lib/gecoder/version.rb

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

data/lib/gecoder.rb

@@ -1,4 +1,5 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
 
+require 'gecoder/version'
 require 'gecoder/bindings'
 require 'gecoder/interface'

data/specs/binding_changes.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Space', :shared => true do
+  it 'should give different indices when creating int variables' do
+    @space.new_int_vars(0, 17).should_not equal(@space.new_int_vars(0, 17))
+  end
+  
+  it 'should give different indices when creating bool variables' do
+    @space.new_bool_vars().should_not equal(@space.new_bool_vars())
+  end
+  
+  it 'should give different indices when creating multiple int variables' do
+    @space.new_int_vars(0, 17, 17).uniq.size.should equal(17)
+  end
+  
+  it 'should give different indices when creating multiple bool variables' do
+    @space.new_bool_vars(17).uniq.size.should equal(17)
+  end
+  
+  it 'should not return nil for created int variables' do
+    @space.new_int_vars(0, 17, 4).each do |i|
+      @space.int_var(i).should_not be_nil
+    end
+  end
+  
+  it 'should not return nil for created int variables' do
+    @space.new_bool_vars(4).each do |i|
+      @space.bool_var(i).should_not be_nil
+    end
+  end
+  
+  it 'should return nil when requesting int variables with negative indices' do
+    @space.int_var(-1).should be_nil
+  end
+  
+  it 'should return nil when requesting bool variables with negative indices' do
+    @space.bool_var(-1).should be_nil
+  end
+end
+
+describe Gecode::Raw::Space, ' (new)' do
+  before do
+    @space = Gecode::Raw::Space.new
+  end
+  
+  it 'should return nil when requesting int variables' do
+    @space.int_var(0).should be_nil
+  end
+  
+  it 'should return nil when requesting bool variables' do
+    @space.bool_var(0).should be_nil
+  end
+  
+  it_should_behave_like 'Space'
+end
+
+describe Gecode::Raw::Space, ' (with items)' do
+  before do
+    @space = Gecode::Raw::Space.new
+    @first = @space.new_int_vars(1, 4).first
+    @second = @space.new_int_vars(-5, 5).first
+  end
+  
+  it_should_behave_like 'Space'
+  
+  it 'should give int variables with the correct domains' do
+    @space.int_var(@first).min.should equal(1)
+    @space.int_var(@first).max.should equal(4)
+    @space.int_var(@second).min.should equal(-5)
+    @space.int_var(@second).max.should equal(5)
+  end
+end

data/specs/bool_var.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'non-empty bool variable', :shared => true do
+  it 'should give a NoMethodError when calling a method that doesn\'t exist' do
+    lambda{ @var.this_method_does_not_exists }.should raise_error(NoMethodError)
+  end
+end
+
+describe Gecode::FreeBoolVar, '(not assigned)' do
+  before do
+    model = Gecode::Model.new
+    @var = model.bool_var
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+end

data/specs/branch.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class BranchSampleProblem < Gecode::Model
+  attr :vars
+  attr :bools
+  
+  def initialize
+    @vars = int_var_array(2, 0..3)
+    @bools = bool_var_array(2)
+  end
+end
+
+describe Gecode::Model, ' (branch)' do
+  before do
+    @model = BranchSampleProblem.new
+    @vars = @model.vars
+    @bools = @model.bools
+  end
+
+  it 'should pass the variables given in int arrays' do
+    Gecode::Raw.should_receive(:branch).once.and_return{ |s, vars, x, y| vars }
+    int_var_array = @model.branch_on @vars
+    int_var_array.size.should equal(2)
+    2.times do |i|
+      int_var_array.at(i).should have_domain(0..3)
+    end
+  end
+  
+  it 'should pass the variables given in bool arrays' do
+    Gecode::Raw.should_receive(:branch).once.and_return{ |s, vars, x, y| vars }
+    bool_var_array = @model.branch_on @bools
+    bool_var_array.size.should equal(2)
+  end
+
+  it 'should default to :none and :min' do
+    Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+      anything, Gecode::Raw::BVAR_NONE, Gecode::Raw::BVAL_MIN)
+    @model.branch_on @vars
+  end
+  
+  it 'should ensure that branched int variables are assigned in a solution' do
+    @model.branch_on @vars
+    @model.solve!.vars.each{ |var| var.should be_assigned }
+  end
+  
+  it 'should ensure that branched bool variables are assigned in a solution' do
+    @model.branch_on @bools
+    @model.solve!.bools.each{ |var| var.should be_assigned }
+  end
+
+  supported_var_selectors = {
+    :none                 => Gecode::Raw::BVAR_NONE,
+    :smallest_min         => Gecode::Raw::BVAR_MIN_MIN,
+    :largest_min          => Gecode::Raw::BVAR_MIN_MAX, 
+    :smallest_max         => Gecode::Raw::BVAR_MAX_MIN, 
+    :largest_max          => Gecode::Raw::BVAR_MAX_MAX, 
+    :smallest_size        => Gecode::Raw::BVAR_SIZE_MIN, 
+    :largest_size         => Gecode::Raw::BVAR_SIZE_MAX,
+    :smallest_degree      => Gecode::Raw::BVAR_DEGREE_MIN, 
+    :largest_degree       => Gecode::Raw::BVAR_DEGREE_MAX, 
+    :smallest_min_regret  => Gecode::Raw::BVAR_REGRET_MIN_MIN,
+    :largest_min_regret   => Gecode::Raw::BVAR_REGRET_MIN_MAX,
+    :smallest_max_regret  => Gecode::Raw::BVAR_REGRET_MAX_MIN, 
+    :largest_max_regret   => Gecode::Raw::BVAR_REGRET_MAX_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as variable selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+        anything, gecode_const, an_instance_of(Numeric))
+      @model.branch_on @vars, :variable => name
+    end
+  end
+
+  supported_val_selectors = {
+    :min        => Gecode::Raw::BVAL_MIN,
+    :med        => Gecode::Raw::BVAL_MED,
+    :max        => Gecode::Raw::BVAL_MAX,
+    :split_min  => Gecode::Raw::BVAL_SPLIT_MIN,
+    :split_max  => Gecode::Raw::BVAL_SPLIT_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as value selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+        anything, an_instance_of(Numeric), gecode_const)
+      @model.branch_on @vars, :value => name
+    end
+  end
+
+  it 'should raise errors for unrecognized var selection strategies' do
+    lambda do 
+      @model.branch_on @vars, :variable => :foo 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized val selection strategies' do
+    lambda do 
+      @model.branch_on @vars, :value => :foo 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise errors for unrecognized options' do
+    lambda do
+      @model.branch_on @vars, :foo => 5 
+    end.should raise_error(ArgumentError)
+  end
+end