gecoder-with-gecode 0.7.1

data/specs/constraints/sort.rb

@@ -0,0 +1,175 @@
+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(
+          an_instance_of(Gecode::Raw::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(
+          an_instance_of(Gecode::Raw::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.values
+    values.should == values.sort
+  end
+  
+  it 'should allow negation' do
+    @vars.must_not_be.sorted
+    @model.solve!
+    values = @vars.values
+    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(
+        an_instance_of(Gecode::Raw::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.values
+    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(
+        an_instance_of(Gecode::Raw::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.values
+    sorted_values.should == sorted_values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.value) }
+    @indices.values.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,122 @@
+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
+    @model.allow_space_access do
+      @int_enum.to_int_var_array.should be_kind_of(Gecode::Raw::IntVarArray)
+    end
+  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
+    @bool_enum = @model.bool_var_array(3)
+  end
+  
+  it 'should convert to a bool var array' do
+    @model.allow_space_access do
+      @bool_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+    end
+  end
+end
+
+describe Gecode::SetEnumMethods do
+  before do
+    @model = Gecode::Model.new
+    @set_enum = @model.set_var_array(3, [0], 0..1)
+  end
+  
+  it 'should convert to a set var array' do
+    @model.allow_space_access do
+      @set_enum.to_set_var_array.should be_kind_of(Gecode::Raw::SetVarArray)
+    end
+  end
+  
+  it 'should compute the smallest upper bound union range' do
+    @set_enum.upper_bound_range.should == (0..1)
+    (@set_enum << @model.set_var([], -4..4)).upper_bound_range.should == (-4..4)
+  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,144 @@
+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 include(i)
+    end
+  end
+  
+  it 'should not contain elements outside its domain' do
+    @var.should_not include(@domain.min - 1)
+    @var.should_not include(@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
+  
+  it 'should raise error when trying to access assigned value' do
+    lambda{ @var.value }.should raise_error(RuntimeError)
+  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 include(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
+
+describe Gecode::FreeIntVar, ' (assigned)' do
+  before do
+    @domain = 1
+    model = Gecode::Model.new
+    @var = model.int_var(*@domain)
+  end
+
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should give the assigned number when inspecting' do
+    @var.inspect.should include(" #{@domain[0]}>")
+  end
+end
+
+describe Gecode::FreeIntVar, ' (not assigned)' do
+  before do
+    @domain = 1..2
+    model = Gecode::Model.new
+    @var = model.int_var(@domain)
+  end
+
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it 'should give the domain range when inspecting' do
+    @var.inspect.should include(" #{@domain.first}..#{@domain.last}>")
+  end
+end