gecoder 0.3.0 → 0.4.0

data/specs/constraints/sort.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class SortSampleProblem < Gecode::Model
+  attr :vars
+  attr :sorted
+  attr :indices
+  
+  def initialize
+    @vars = int_var_array(4, 10..19)
+    @sorted = int_var_array(4, 10..19)
+    @indices = int_var_array(4, 0..9)
+    
+    # To make it more interesting
+    @vars.must_be.distinct
+    
+    branch_on @vars
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Sort, ' (without :as and :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    @invoke_options = lambda do |hash| 
+      @vars.must_be.sorted(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:rel).exactly(@vars.size - 1).times.with(
+          @model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar), strength)
+      else
+        Gecode::Raw.should_receive(:rel).exactly(@vars.size - 1).times.with(
+          @model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+      end
+    end
+  end
+  
+  it 'should translate into n relation constraints' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+  end
+
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted
+    values = @model.solve!.vars.map{ |x| x.val }
+    values.should == values.sort
+  end
+  
+  it 'should allow negation' do
+    @vars.must_not_be.sorted
+    @model.solve!
+    values = @vars.map{ |x| x.val }
+    values.should_not == values.sort
+  end
+  
+  it_should_behave_like 'constraint with options'
+end
+
+describe Gecode::Constraints::IntEnum::Sort, ' (with :as)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @invoke_options = lambda do |hash| 
+      @vars.must_be.sorted hash.update(:as => @sorted) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:sortedness).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVarArray), strength)
+    end
+  end
+  
+  it 'should translate into a sortedness constraints' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+  end
+  
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted(:as => @sorted)
+    @model.solve!
+    values = @sorted.map{ |x| x.val }
+    values.should == values.sort
+  end
+  
+  it 'should not allow targets that are not int var enums' do
+    lambda{ @vars.must_be.sorted(:as => 'hello') }.should raise_error(TypeError) 
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @vars.must_not_be.sorted(:as => @sorted) }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end
+
+describe Gecode::Constraints::IntEnum::Sort, ' (with :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    @indices = @model.indices
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @invoke_options = lambda do |hash| 
+      @vars.must_be.sorted hash.update(:order => @indices, :as => @sorted) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:sortedness).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVarArray),
+        an_instance_of(Gecode::Raw::IntVarArray), strength)
+    end
+  end
+  
+  it 'should translate into a sortedness constraints' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+  end
+  
+  it 'should translate into a sortedness constraints, even without a target' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @vars.must_be.sorted(:order => @indices) 
+    @model.solve!
+  end
+  
+  it 'should constraint variables to be sorted with the specified indices' do
+    @vars.must_be.sorted(:as => @sorted, :order => @indices)
+    @model.solve!
+    sorted_values = @sorted.map{ |x| x.val }
+    sorted_values.should == sorted_values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.val) }
+    @indices.map{ |i| i.val }.should == expected_indices
+  end
+  
+  it 'should not allow targets that are not int var enums' do
+    lambda do
+      @vars.must_be.sorted(:as => 'hello', :order => @indices)
+    end.should raise_error(TypeError) 
+  end
+  
+  it 'should not allow order that are not int var enums' do
+    lambda do
+      @vars.must_be.sorted(:as => @sorted, :order => 'hello')
+    end.should raise_error(TypeError) 
+  end
+  
+  it 'should not allow negation' do
+    lambda do
+      @vars.must_not_be.sorted(:as => @sorted, :order => @indices)
+    end.should raise_error(Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end

data/specs/enum_matrix.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::Util::EnumMatrix do
+  before do
+    @matrix = Gecode::Util::EnumMatrix[[0, 1], [1, 0]]
+  end
+  
+  it 'should be enumerable' do
+    @matrix.should be_kind_of(Enumerable)
+  end
+  
+  it 'should produce rows that are enumerable' do
+    @matrix.row(0).should be_kind_of(Enumerable)
+    @matrix.row(0).inject([]){ |arr, e| arr << e }.should == [0, 1]
+  end
+  
+  it 'should produce columns that are enumerable' do
+    @matrix.column(0).should be_kind_of(Enumerable)
+  end
+  
+  it 'should produce submatrices that are enumerable' do
+    @matrix.minor(0,1,0,1).should be_kind_of(Enumerable)
+  end
+end
+
+describe Gecode::Util::EnumMatrix, ' (when wrapped)' do
+  before do
+    @model = Gecode::Model.new
+    @matrix = @model.wrap_enum(Gecode::Util::EnumMatrix[[0, 1], [1, 0]])
+  end
+  
+  it 'should produce rows that are wrapped' do
+    @matrix.row(0).should respond_to(:model)
+  end
+  
+  it 'should produce columns that are enumerable' do
+    @matrix.column(0).should respond_to(:model)
+  end
+  
+  it 'should produce submatrices that are enumerable' do
+    @matrix.minor(0,1,0,1).should respond_to(:model)
+  end
+end

data/specs/enum_wrapper.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::Model, ' (enum wrapping)' do
+  before do
+    @model = Gecode::Model.new
+    @bool = @model.bool_var
+    @int = @model.int_var(1..2)
+  end
+
+  it 'should only allow enumerables to be wrapped' do
+    lambda do
+      @model.wrap_enum(17) 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should allow enumerables of bool variables to be wrapped' do
+    lambda do
+      enum = [@bool]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  it 'should allow enumerables of int variables to be wrapped' do
+    lambda do
+      enum = [@int]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  it 'should allow enumerables of fixnums to be wrapped' do
+    lambda do
+      enum = [17]
+      @model.wrap_enum(enum) 
+    end.should_not raise_error
+  end
+  
+  it 'should not allow empty enumerables to be wrapped' do
+    lambda do 
+      @model.wrap_enum([]) 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not allow enumerables without variables or fixnums to be wrapped' do
+    lambda do 
+      @model.wrap_enum(['foo']) 
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should not allow enumerables with only some variables to be wrapped' do
+    lambda do 
+      enum = [@bool, 'foo']
+      @model.wrap_enum(enum) 
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should not allow enumerables with mixed types of variables to be wrapped' do
+    lambda do 
+      enum = [@bool, @int]
+      @model.wrap_enum(enum) 
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::IntEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @int_enum = @model.int_var_array(3, 0..1)
+  end
+  
+  it 'should convert to an int var array' do
+    @int_enum.to_int_var_array.should be_kind_of(Gecode::Raw::IntVarArray)
+  end
+  
+  it 'should compute the smallest domain range' do
+    @int_enum.domain_range.should == (0..1)
+    (@int_enum << @model.int_var(-4..4)).domain_range.should == (-4..4)
+  end
+end
+
+describe Gecode::BoolEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @int_enum = @model.bool_var_array(3)
+  end
+  
+  it 'should convert to a bool var array' do
+    @int_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+  end
+end
+
+describe Gecode::FixnumEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @enum = @model.instance_eval{ wrap_enum([7, 14, 17, 4711]) }
+  end
+  
+  it 'should compute the smallest domain range' do
+    @enum.domain_range.should == (7..4711)
+  end
+end

data/specs/int_var.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'non-empty int variable', :shared => true do
+  it 'should have min equal to the lower domain bound' do
+    @var.min.should equal(@domain.min)
+  end
+  
+  it 'should have max equal to the upper domain bound' do
+    @var.max.should equal(@domain.max)
+  end
+  
+  it 'should have size equal to the domain size' do
+    @var.size.should equal(@domain.size)
+  end
+  
+  it 'should contain every element in its domain' do 
+    @domain.each do |i|
+      @var.should be_in(i)
+    end
+  end
+  
+  it 'should not contain elements outside its domain' do
+    @var.should_not be_in(@domain.min - 1)
+    @var.should_not be_in(@domain.max + 1)
+  end
+  
+  it 'should have a width equal to the domain width' do
+    @var.width.should equal(@domain.max - @domain.min + 1)
+  end
+  
+  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
+  
+  it 'should have a zero degree' do
+    @var.degree.should be_zero
+  end
+end
+
+describe Gecode::FreeIntVar, ' (with range domain of size > 1)' do
+  before do
+    @range = -4..3
+    @domain = @range.to_a
+    model = Gecode::Model.new
+    @var = model.int_var(@range)
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should have a range domain' do
+    @var.should be_range
+  end
+end
+
+describe Gecode::FreeIntVar, ' (defined with three-dot range)' do
+  before do
+    @range = -4...3
+    @domain = @range.to_a
+    model = Gecode::Model.new
+    @var = model.int_var(@range)
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+end
+
+describe Gecode::FreeIntVar, ' (with non-range domain of size > 1)' do
+  before do
+    @domain = [-3, -2, -1, 1]
+    model = Gecode::Model.new
+    @var = model.int_var(*@domain)
+  end
+
+  it_should_behave_like 'non-empty int variable'
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should not be a range domain' do
+    @var.should_not be_range
+  end
+  
+  it 'should not contain the domain\'s holes' do
+    @var.should_not be_in(0)
+  end
+end
+
+describe Gecode::FreeIntVar, '(with a domain of size 1)' do
+  before do
+    @domain = [1]
+    model = Gecode::Model.new
+    @var = model.int_var(*@domain)
+  end
+  
+  it_should_behave_like 'non-empty int variable'
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should be a range domain' do
+    @var.should be_range
+  end
+end

data/specs/model.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::Model, ' (integer creation)' do
+  before do
+    @model = Gecode::Model.new
+  end
+
+  it 'should allow the creation of int variables with range' do
+    range = 0..3
+    @model.int_var(range).should have_domain(range)
+  end
+  
+  # This currently fails, see specs/int_var for an explanation.
+  it 'should allow the creation of int variables with non-range domains' do
+    domain = [1, 3, 5]
+    @model.int_var(*domain).should have_domain(domain)
+  end
+  
+  it 'should allow the creation of int variables with single element domains' do
+    domain = 3
+    @model.int_var(domain).should have_domain([domain])
+  end
+  
+  it 'should not accept empty domains' do
+    lambda{ @model.int_var }.should raise_error(ArgumentError)
+    lambda{ @model.int_var_array(1) }.should raise_error(ArgumentError)
+  end
+  
+  it 'should allow the creation of int-var arrays with range domains' do
+    range = 0..3
+    count = 5
+    vars = @model.int_var_array(count, range)
+    vars.size.should equal(count)
+    vars.each{ |var| var.should have_domain(range) }
+  end
+  
+  it 'should allow the creation of int-var arrays with non-range domains' do
+    domain = [1,3,5]
+    count = 5
+    vars = @model.int_var_array(count, *domain)
+    vars.size.should equal(count)
+    vars.each{ |var| var.should have_domain(domain) }
+  end
+  
+  it 'should allow the creation of int-var matrices with range domains' do
+    range = 0..3
+    rows = 5
+    columns = 4
+    vars = @model.int_var_matrix(rows, columns, range)
+    vars.row_size.should equal(rows)
+    vars.column_size.should equal(columns)
+    vars.each{ |var| var.should have_domain(range) }
+  end
+  
+  it 'should allow the creation of int-var matrices with non-range domains' do
+    domain = [1,3,5]
+    rows = 5
+    columns = 4
+    vars = @model.int_var_matrix(rows, columns, *domain)
+    vars.row_size.should equal(rows)
+    vars.column_size.should equal(columns)
+    vars.each{ |var| var.should have_domain(domain) }
+  end
+end
+
+describe Gecode::Model, ' (bool creation)' do
+  before do
+    @model = Gecode::Model.new
+  end
+
+  it 'should allow the creation of boolean variables' do
+    @model.bool_var.should_not be_nil
+  end
+  
+  it 'should allow the creation of arrays of boolean variables' do
+    @model.bool_var_array(3).size.should equal(3)
+  end
+  
+  it 'should allow the creation of matrices of boolean variables' do
+    matrix = @model.bool_var_matrix(3, 4)
+    matrix.row_size.should equal(3)
+    matrix.column_size.should equal(4)
+  end
+end

data/specs/search.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'set'
+
+class SampleProblem < Gecode::Model
+  attr :var
+  attr :array
+  attr :hash
+  attr :nested_enum
+  
+  def initialize(domain)
+    vars = self.int_var_array(1,domain)
+    @var = vars.first
+    @var.must > 1
+    @array = [@var]
+    @hash = {:a => var}
+    @nested_enum = [1,2,[@var],[7, {:b => var}]]
+    
+    branch_on vars, :variable => :smallest_size, :value => :min
+  end
+end
+
+describe Gecode::Model, ' (with multiple solutions)' do
+  before do
+    @domain = 0..3
+    @solved_domain = [2]
+    @model = SampleProblem.new(@domain)
+  end
+
+  it 'should pass a solution to the block given in #solution' do
+    @model.solution do |s|
+      s.var.should have_domain(@solved_domain)
+    end
+  end
+  
+  it 'should only evaluate the block for one solution in #solution' do
+    i = 0
+    @model.solution{ |s| i += 1 }
+    i.should equal(1)
+  end
+  
+  it 'should return the result of the block when calling #solution' do
+    @model.solution{ |s| 'test' }.should == 'test'
+  end
+  
+  it 'should pass every solution to #each_solution' do
+    solutions = []
+    @model.each_solution do |s|
+      solutions << s.var.val
+    end
+    Set.new(solutions).should == Set.new([2,3])
+  end
+end
+
+describe Gecode::Model, ' (after #solve!)' do
+  before do
+    @domain = 0..3
+    @solved_domain = [2]
+    @model = SampleProblem.new(@domain)
+    @model.solve!
+  end
+
+  it 'should have updated the variables domains' do
+    @model.var.should have_domain(@solved_domain)
+  end
+
+  it 'should have updated variables in arrays' do
+    @model.array.first.should have_domain(@solved_domain)
+  end
+  
+  it 'should have updated variables in hashes' do
+    @model.hash.values.first.should have_domain(@solved_domain)
+  end
+  
+  it 'should have updated variables in nested enums' do
+    enum = @model.solve!.nested_enum
+    enum[2].first.should have_domain(@solved_domain)
+    enum[3][1][:b].should have_domain(@solved_domain)
+    
+    enum = @model.nested_enum
+    enum[2].first.should have_domain(@solved_domain)
+    enum[3][1][:b].should have_domain(@solved_domain)
+  end
+end
+
+describe 'reset model', :shared => true do
+  it 'should have reset variables' do
+    @model.var.should have_domain(@reset_domain)
+  end
+  
+  it 'should have reset variables in nested enums' do
+    enum = @model.nested_enum
+    enum[2].first.should have_domain(@reset_domain)
+    enum[3][1][:b].should have_domain(@reset_domain)
+  end
+end
+
+describe Gecode::Model, ' (after #reset!)' do
+  before do
+    @domain = 0..3
+    @reset_domain = 2..3
+    @model = SampleProblem.new(@domain)
+    @model.solve!
+    @model.reset!
+  end
+  
+  it_should_behave_like 'reset model'
+end
+
+describe Gecode::Model, ' (after #solution)' do
+  before do
+    @domain = 0..3
+    @reset_domain = 2..3
+    @model = SampleProblem.new(@domain)
+    @model.solution{ |s| }
+  end
+  
+  it_should_behave_like 'reset model'
+end
+
+describe Gecode::Model, ' (after #each_solution)' do
+  before do
+    @domain = 0..3
+    @reset_domain = 2..3
+    @model = SampleProblem.new(@domain)
+    @model.each_solution{ |s| }
+  end
+  
+  it_should_behave_like 'reset model'
+end
+
+describe Gecode::Model, ' (without solution)' do
+  before do
+    @domain = 0..3
+    @model = SampleProblem.new(@domain)
+    @model.var.must < 0
+  end
+  
+  it 'should return nil when calling #solution' do
+    @model.var.must < 0
+    @model.solution{ |s| 'test' }.should be_nil
+  end
+  
+  it 'should return nil when calling #solve!' do
+    @model.solve!.should be_nil
+  end
+end
+
+describe Gecode::Model, ' (without constraints)' do
+  before do
+    @model = Gecode::Model.new
+    @x = @model.int_var(0..1)
+  end
+  
+  it 'should produce a solution' do
+    @model.solve!.should_not be_nil
+  end
+end