gecoder-with-gecode 0.7.1

data/specs/logging.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::LoggingLayer do
+  before do
+    # Enable logging.
+    Gecode.instance_eval{ remove_const(:Raw) }
+    Gecode.const_set(:Raw, Gecode::LoggingLayer)
+  end
+  
+  after do
+    # Disable logging.
+    Gecode.instance_eval{ remove_const(:Raw) }
+    Gecode.const_set(:Raw, GecodeRaw)
+  end
+
+  it "shouldn't interfere with calls through Gecode::Raw" do
+    lambda do
+      model = Gecode::Model.new
+      int_var = model.int_var(0..9)
+      int_var.must >= 5
+      model.solve!
+    end.should_not raise_error
+  end
+end

data/specs/model.rb

@@ -0,0 +1,190 @@
+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
+  
+  it 'should allow the creation of int variables without specified domain' do
+    var = @model.int_var
+    var.should be_range
+    var.min.should == Gecode::Raw::Limits::Int::INT_MIN
+    var.max.should == Gecode::Raw::Limits::Int::INT_MAX
+  end
+
+  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 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
+
+describe Gecode::Model, ' (set creation)' do
+  before do
+    @model = Gecode::Model.new
+    @glb_range = 0..3
+    @lub_range = 0..5
+    @glb_enum = [0, 3]
+    @lub_enum = [0, 1, 2, 3, 5]
+    @lower_card = 1
+    @upper_card = 3
+  end
+  
+  it 'should allow the creation of set variables without specified bounds' do
+    var = @model.set_var
+    var.lower_bound.size.should == 0
+    var.upper_bound.min.should == Gecode::Raw::Limits::Set::INT_MIN
+    var.upper_bound.max.should == Gecode::Raw::Limits::Set::INT_MAX
+  end
+
+  it 'should allow the creation of set variables with glb range and lub range' do
+    @model.set_var(@glb_range, @lub_range).should have_bounds(@glb_range, 
+      @lub_range) 
+  end
+  
+  it 'should allow the creation of set variables with glb enum and lub range' do
+    @model.set_var(@glb_enum, @lub_range).should have_bounds(@glb_enum, 
+      @lub_range) 
+  end
+  
+  it 'should allow the creation of set variables with glb range and lub enum' do
+    @model.set_var(@glb_range, @lub_enum).should have_bounds(@glb_range, 
+      @lub_enum) 
+  end
+  
+  it 'should allow the creation of set variables with glb enum and lub enum' do
+    @model.set_var(@glb_enum, @lub_enum).should have_bounds(@glb_enum, 
+      @lub_enum) 
+  end
+  
+  it 'should allow the creation of set variables with specified lower cardinality bound' do
+    @model.set_var(@glb_range, @lub_range, 
+      @lower_card).cardinality.begin.should >= @lower_card
+  end
+  
+  it 'should allow the creation of set variables with specified cardinality range' do
+    var = @model.set_var(@glb_range, @lub_range, @lower_card..@upper_card)
+    var.cardinality.end.should <= @upper_card
+    var.cardinality.begin.should >= @lower_card
+  end
+  
+  it 'should allow the creation of arrays of set variables' do
+    arr = @model.set_var_array(3, @glb_enum, @lub_enum, @lower_card..@upper_card)
+    arr.size.should == 3
+    arr.each do |var|
+      var.should have_bounds(@glb_enum, @lub_enum)
+      var.cardinality.end.should <= @upper_card
+      var.cardinality.begin.should >= @lower_card
+    end
+  end
+  
+  it 'should allow the creation of matrices of set variables' do
+    matrix = @model.set_var_matrix(4, 5, @glb_enum, @lub_enum, 
+      @lower_card..@upper_card)
+    matrix.row_size.should == 4
+    matrix.column_size.should == 5
+    matrix.each do |var|
+      var.should have_bounds(@glb_enum, @lub_enum)
+      var.cardinality.end.should <= @upper_card
+      var.cardinality.begin.should >= @lower_card
+    end
+  end
+  
+  it 'should raise error if glb and lub are not valid when they are given as range' do
+    lambda{ @model.set_var(@lub_range, @glb_range).should }.should raise_error(
+      ArgumentError)  
+  end
+  
+  it 'should raise error if glb and lub are not valid when one is given as enum' do
+    lambda{ @model.set_var(@lub_range, @glb_enum).should }.should raise_error(
+      ArgumentError)
+  end
+  
+  it 'should raise error if glb and lub are not valid when both are given as enums' do
+    lambda{ @model.set_var(@lub_enum, @glb_enum).should }.should raise_error(
+      ArgumentError)  
+  end
+end
+
+describe Gecode::Model, ' (space access restriction)' do
+  before do
+    @model = Gecode::Model.new
+  end
+
+  it 'should raise error if not allowed to access space' do
+    lambda{ @model.active_space }.should raise_error(RuntimeError)
+  end
+  
+  it 'should not raise error because of space restriction if allowed to access space' do
+    lambda do
+      @model.allow_space_access do
+        @model.active_space
+      end
+    end.should_not raise_error(RuntimeError)
+  end
+end

data/specs/search.rb

@@ -0,0 +1,246 @@
+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
+
+class SampleOptimizationProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize
+    @x,@y = int_var_array(2, 0..5)
+    @z = int_var(0..25)
+    (@x * @y).must == @z 
+    
+    branch_on wrap_enum([@x, @y]), :variable => :smallest_size, :value => :min
+  end
+end
+
+class SampleOptimizationProblem2 < Gecode::Model
+  attr :money
+  
+  def initialize
+    @money = int_var_array(3, 0..9)
+    @money.must_be.distinct
+    @money.to_number.must < 500 # Otherwise it takes some time.
+    
+    branch_on @money, :variable => :smallest_size, :value => :min
+  end
+end
+
+class Array
+  # Computes a number of the specified base using the array's elements as 
+  # digits.
+  def to_number(base = 10)
+    inject{ |result, variable| variable + result * base }
+  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.value
+    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
+  
+  it 'should return nil when calling #optimize!' do
+    @model.optimize!{}.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
+
+describe Gecode::Model, '(optimization search)' do
+  it 'should optimize the solution' do
+    solution = SampleOptimizationProblem.new.optimize! do |model, best_so_far|
+      model.z.must > best_so_far.z.value
+    end
+    solution.should_not be_nil
+    solution.x.value.should == 5
+    solution.y.value.should == 5
+    solution.z.value.should == 25
+  end
+  
+  it 'should not be bothered by garbage collecting' do
+    # This goes through 400+ spaces.
+    solution = SampleOptimizationProblem2.new.optimize! do |model, best_so_far|
+      model.money.to_number.must > best_so_far.money.values.to_number
+    end
+    solution.should_not be_nil
+    solution.money.values.to_number.should == 498
+  end
+  
+  it 'should raise error if no constrain proc has been defined' do
+    lambda do 
+      Gecode::Model.constrain(nil, nil) 
+    end.should raise_error(NotImplementedError)
+  end
+  
+  it 'should not have problems with variables being created in the optimization block' do
+    solution = SampleOptimizationProblem.new.optimize! do |model, best_so_far|
+      tmp = model.int_var(0..25)
+      tmp.must == model.z
+      tmp.must > best_so_far.z.value
+    end
+    solution.should_not be_nil
+    solution.x.value.should == 5
+    solution.y.value.should == 5
+    solution.z.value.should == 25
+  end
+
+  it 'should not have problems with variables being created in the optimization block (2)' do
+    solution = SampleOptimizationProblem.new.optimize! do |model, best_so_far|
+      tmp = model.int_var(0..25)
+      tmp.must == model.z
+      (tmp + tmp).must > best_so_far.z.value*2
+    end
+    solution.should_not be_nil
+    solution.x.value.should == 5
+    solution.y.value.should == 5
+    solution.z.value.should == 25
+  end
+end