gecoder-with-gecode 0.9.0-x86-mswin32-60

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,325 @@
+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::IntLimits::MIN
+    var.max.should == Gecode::Raw::IntLimits::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 arrays without specified domain' do
+    count = 5
+    vars = @model.int_var_array(count)
+    vars.size.should equal(count)
+    vars.each do |var|
+      var.should be_range
+      var.min.should == Gecode::Raw::IntLimits::MIN
+      var.max.should == Gecode::Raw::IntLimits::MAX
+    end
+  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
+  
+  it 'should allow the creation of int-var matrices without specified domain' do
+    rows = 5
+    columns = 4
+    vars = @model.int_var_matrix(rows, columns)
+    vars.row_size.should equal(rows)
+    vars.column_size.should equal(columns)
+    vars.each do |var|
+      var.should be_range
+      var.min.should == Gecode::Raw::IntLimits::MIN
+      var.max.should == Gecode::Raw::IntLimits::MAX
+    end
+  end
+  
+  it 'should raise error if the domain is of incorrect type' do
+    lambda do 
+      @model.int_var(nil)
+    end.should raise_error(TypeError) 
+  end
+  
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.int_var 0
+      GC.start
+    end.should_not raise_error
+  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
+  
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.bool_var
+      GC.start
+    end.should_not raise_error
+  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::SetLimits::MIN
+    var.upper_bound.max.should == Gecode::Raw::SetLimits::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 arrays of set variables without specified bounds' do
+    vars = @model.set_var_array(3)
+    vars.each do |var|
+      var.lower_bound.size.should == 0
+      var.upper_bound.min.should == Gecode::Raw::SetLimits::MIN
+      var.upper_bound.max.should == Gecode::Raw::SetLimits::MAX
+    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 allow the creation of matrices of set variables without specified bounds' do
+    matrix = @model.set_var_matrix(4, 5)
+    matrix.each do |var|
+      var.lower_bound.size.should == 0
+      var.upper_bound.min.should == Gecode::Raw::SetLimits::MIN
+      var.upper_bound.max.should == Gecode::Raw::SetLimits::MAX
+    end
+  end
+  
+  it 'should raise error if glb and lub are not valid when they are given as range' do
+    lambda do 
+      @model.set_var(@lub_range, @glb_range)
+    end.should raise_error(ArgumentError)  
+  end
+  
+  it 'should raise error if glb and lub are not valid when one is given as enum' do
+    lambda do
+      @model.set_var(@lub_range, @glb_enum)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if glb and lub are not valid when both are given as enums' do
+    lambda do
+      @model.set_var(@lub_enum, @glb_enum)
+    end.should raise_error(ArgumentError)  
+  end
+  
+  it 'should raise error if the glb and lub are of incorrect type' do
+    lambda do 
+      @model.set_var("foo\n", "foo\ns")
+    end.should raise_error(TypeError) 
+  end
+
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.set_var(@glb_range, @lub_range)
+      GC.start
+    end.should_not raise_error
+  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
+
+describe Gecode::Model, ' (accessible variable creation)' do
+  before do
+    @model = Class.new(Gecode::Model).new
+  end
+
+  it 'should allow creation of named variable using #foo_is_a' do
+    var = @model.int_var(17)
+    lambda{ @model.foo }.should raise_error(NoMethodError)
+    @model.instance_eval{ foo_is_a var }
+    lambda{ @model.foo }.should_not raise_error
+    @model.foo.should == var
+  end
+
+  it 'should allow creation of named variable using #foo_is_an' do
+    var = @model.int_var(17)
+    lambda{ @model.foo }.should raise_error(NoMethodError)
+    @model.instance_eval{ foo_is_an var }
+    lambda{ @model.foo }.should_not raise_error
+    @model.foo.should == var
+  end
+
+  it 'should only allow one argument to be given to #foo_is_a' do
+    lambda do
+      @model.instance_eval{ foo_is_a }
+    end.should raise_error(ArgumentError)
+    lambda do
+      @model.instance_eval{ foo_is_a bool_var, bool_var }
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should only define the variable in the current instance' do
+    klass = Class.new Gecode::Model
+    model_a = klass.new
+    model_b = klass.new
+
+    model_a.instance_eval{ bar_is_a bool_var }
+    lambda{ model_a.bar }.should_not raise_error
+    lambda{ model_b.bar }.should raise_error(NoMethodError)
+  end
+
+  it 'should raise error if a method would be overwritten' do
+    var = @model.int_var(17)
+    lambda{ @model.class }.should_not raise_error
+    lambda do
+      @model.instance_eval{ class_is_an var } 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise error if an instance variable would be overwritten' do
+    @model.instance_eval{ @foo = 17 }
+    var = @model.int_var(17)
+    lambda do
+      @model.instance_eval{ foo_is_a var } 
+    end.should raise_error(ArgumentError)
+  end
+end

data/specs/model_sugar.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode, ' (Model sugar)' do
+  it 'should provide #solve as sugar for constructing a model and running solve!' do
+    Gecode.solve do
+      numbers_is_an int_var_array(2, 0..5)
+      x, y = numbers
+      (x * y).must == 25
+      branch_on numbers
+    end.numbers.values.should == [5,5]
+  end
+
+  it 'should provide #maximize as sugar for constructing a model and running maximize!' do
+    Gecode.maximize :z do
+      z_is_an int_var
+      x, y = vars = int_var_array(2, 0..5)
+      (x*2 - y).must == z
+      branch_on vars
+    end.z.value.should equal(10)
+  end
+
+  it 'should provide #minimize as sugar for constructing a model and running minimize!' do
+    Gecode.minimize :z do
+      z_is_an int_var
+      x, y = vars = int_var_array(2, 0..5)
+      (x*2 - y).must == z
+      branch_on vars
+    end.z.value.should equal(-5)
+  end
+end

data/specs/search.rb

@@ -0,0 +1,383 @@
+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 update the search statistics before yielding to #solution' do
+    @model.solution do |s|
+      @model.search_stats.should_not be_nil
+    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
+  
+  it 'should update the search statistics before yielding to #each_solution' do
+    solutions = []
+    old_stats = @model.search_stats
+    old_stats.should be_nil
+    @model.each_solution do |s|
+      solutions << s.var.value
+      @model.search_stats.should_not == old_stats
+      @model.search_stats.should_not be_nil
+      old_stats = @model.search_stats
+    end
+  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
+  
+  it 'should have updated the search statistics' do
+    stats = @model.search_stats
+    stats[:propagations].should == 0
+    stats[:failures].should == 0
+    stats[:clones].should_not be_nil
+    stats[:commits].should_not be_nil
+    stats[:memory].should > 0
+  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
+  
+  it 'should have cleared the search statistics' do
+    @model.search_stats.should be_nil
+  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.solution{ |s| 'test' }.should be_nil
+  end
+
+  it 'should not yield anything to #each_solution' do 
+    @model.each_solution{ |s| violated }
+  end
+  
+  it 'should raise NoSolutionError when calling #solve!' do
+    lambda do 
+      @model.solve!
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+  
+  it 'should raise NoSolutionError when calling #optimize!' do
+    lambda do 
+      @model.optimize!{}
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+
+  it 'should raise NoSolutionError when calling #minimize!' do
+    lambda do 
+      @model.optimize!{}
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+
+  it 'should raise NoSolutionError when calling #maximize!' do
+    lambda do 
+      @model.maximize!(:var)
+    end.should raise_error(Gecode::NoSolutionError)
+  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
+  
+  it 'should update the search statistics' do
+    model = SampleOptimizationProblem.new
+    solution = model.maximize! :z
+    
+    stats = model.search_stats
+    stats.should_not be_nil
+    stats[:propagations].should be_between(1, 100)
+    stats[:failures].should be_between(1, 100)
+    stats[:clones].should_not be_nil
+    stats[:commits].should_not be_nil
+    stats[:memory].should > 0
+  end
+end
+
+describe 'single variable optimization', :shared => true do
+  it "should support #{@method_name} having the variable given as a symbol" do
+    solution = @model.method(@method_name).call(@variable_name.to_sym)
+    @expect_to_be_correct.call(solution)
+  end
+  
+  it "should support #{@method_name} having the variable given as a string" do
+    solution = @model.method(@method_name).call(@variable_name.to_s)
+    @expect_to_be_correct.call(solution)
+  end
+  
+  it "should raise error if #{@method_name} is given a non-existing method" do
+    lambda do
+      SampleOptimizationProblem.new.method(@method_name).call(:does_not_exist)
+    end.should raise_error(NameError)
+  end
+  
+  it "should raise error if #{@method_name} is given a method that does not return an integer variable" do
+    lambda do
+      SampleOptimizationProblem.new.method(@method_name).call(:object_id)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should update the search statistics' do
+    @model.method(@method_name).call(@variable_name.to_sym)
+    
+    stats = @model.search_stats
+    stats.should_not be_nil
+    stats[:propagations].should be_between(1, 100)
+    stats[:failures].should be_between(1, 100)
+    stats[:clones].should_not be_nil
+    stats[:commits].should_not be_nil
+    stats[:memory].should > 0
+  end
+end
+
+describe Gecode::Model, '(single variable minimization)' do
+  before do
+    @method_name = 'minimize!'
+    @variable_name = 'x'
+    
+    @model = SampleOptimizationProblem.new
+    @model.z.must > 2
+    
+    @expect_to_be_correct = lambda do |solution|
+      solution.should_not be_nil
+      solution.x.value.should == 1
+      solution.y.value.should == 3
+      solution.z.value.should == 3
+    end
+  end
+  
+  it_should_behave_like 'single variable optimization'
+end
+
+describe Gecode::Model, '(single variable maximization)' do
+  before do
+    @method_name = 'maximize!'
+    @variable_name = 'z'
+    
+    @model = SampleOptimizationProblem.new
+    
+    @expect_to_be_correct = lambda do |solution|
+      solution.should_not be_nil
+      solution.x.value.should == 5
+      solution.y.value.should == 5
+      solution.z.value.should == 25
+    end
+  end
+  
+  it_should_behave_like 'single variable optimization'
+end
+