gecoder 0.5.0 → 0.6.0

data/specs/constraints/reification_sugar.rb

@@ -27,10 +27,12 @@ describe Gecode::Constraints::ReifiableConstraint do
   end
   
   it 'should translate disjunctions' do
-    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
       an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
-    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 3, 
       an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
     (@x.must > 0) | (@y.must == 3)
@@ -50,10 +52,12 @@ describe Gecode::Constraints::ReifiableConstraint do
   end
   
   it 'should translate conjunctions' do
-    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
       an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
-    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:rel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 2, 
       an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
     (@x.must > 0) & (@y.must == 2)

data/specs/constraints/set_domain.rb

@@ -14,14 +14,17 @@ describe Gecode::Constraints::Set::Domain do
     @singleton = 0
     
     @expect = lambda do |relation_type, rhs, reif_var, negated|
-      if reif_var.nil? and !negated
-        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-          @set.bind, relation_type, *expect_constant_set(rhs))
-      else
-        params = [@model.active_space, @set.bind, relation_type]
-        params << expect_constant_set(rhs)
-        params << an_instance_of(Gecode::Raw::BoolVar)
-        Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+      @model.allow_space_access do
+        if reif_var.nil? and !negated
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, *expect_constant_set(rhs))
+        else
+          params = [@model.active_space, @set.bind, relation_type]
+          params << expect_constant_set(rhs)
+          params << an_instance_of(Gecode::Raw::BoolVar)
+          Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+        end
       end
     end
     
@@ -91,14 +94,17 @@ describe Gecode::Constraints::Set::Domain, ' (equality)' do
     @singleton = 0
     
     @expect = lambda do |relation_type, rhs, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
-          @set.bind, relation_type, *expect_constant_set(rhs))
-      else
-        params = [@model.active_space, @set.bind, relation_type]
-        params << expect_constant_set(rhs)
-        params << an_instance_of(Gecode::Raw::BoolVar)
-        Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+      @model.allow_space_access do
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, *expect_constant_set(rhs))
+        else
+          params = [@model.active_space, @set.bind, relation_type]
+          params << expect_constant_set(rhs)
+          params << an_instance_of(Gecode::Raw::BoolVar)
+          Gecode::Raw.should_receive(:dom).once.with(*params.flatten)
+        end
       end
     end
     
@@ -152,8 +158,8 @@ describe Gecode::Constraints::Set::Domain, ' (equality)' do
     @set.must == @singleton
     @model.solve!
     @set.should be_assigned
-    @set.should include(@singleton)
-    @set.val_size.should == 1
+    @set.value.should include(@singleton)
+    @set.value.size.should == 1
   end
   
   it 'should constrain the domain with inequality' do

data/specs/constraints/set_relation.rb

@@ -10,13 +10,17 @@ describe Gecode::Constraints::Set::Relation do
     @set2 = @model.set_var([1], 0..3)
     
     @expect = lambda do |relation_type, rhs, reif_var, negated|
-      if reif_var.nil? and !negated
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          @set.bind, relation_type, @set2.bind)
-      else
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          @set.bind, relation_type, @set2.bind, 
-          an_instance_of(Gecode::Raw::BoolVar))
+      @model.allow_space_access do
+        if reif_var.nil? and !negated
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, @set2.bind)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, @set2.bind, 
+            an_instance_of(Gecode::Raw::BoolVar))
+        end
       end
     end
     
@@ -57,13 +61,17 @@ describe Gecode::Constraints::Set::Relation, ' (equality)' do
     @set2 = @model.set_var([1], 0..1)
     
     @expect = lambda do |relation_type, rhs, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          @set.bind, relation_type, @set2.bind)
-      else
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          @set.bind, relation_type, @set2.bind, 
-          an_instance_of(Gecode::Raw::BoolVar))
+      @model.allow_space_access do
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, @set2.bind)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            @set.bind, relation_type, @set2.bind, 
+            an_instance_of(Gecode::Raw::BoolVar))
+        end
       end
     end
     
@@ -119,12 +127,19 @@ describe Gecode::Constraints::Set::Relation, ' (elements)' do
     @int_constant = 2
     @model.branch_on @model.wrap_enum([@set])
     @expect = lambda do |relation_type, rhs|
-      if rhs.kind_of? Fixnum
-        rhs = an_instance_of(Gecode::Raw::IntVar)
+      @model.allow_space_access do
+        if rhs.kind_of? Fixnum
+          rhs = an_instance_of(Gecode::Raw::IntVar)
+        end
+        rhs = rhs.bind if rhs.respond_to? :bind
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          @set.bind, relation_type, rhs)
       end
-      rhs = rhs.bind if rhs.respond_to? :bind
-      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-        @set.bind, relation_type, rhs)
+    end
+    
+    @invoke_options = lambda do |hash|
+      @set.elements.must_be.equal_to(@int_var, hash)
     end
     
     @invoke_options = lambda do |hash|
@@ -165,16 +180,16 @@ describe Gecode::Constraints::Set::Relation, ' (elements)' do
     @int_var.must == 0
     @model.solve!
     @set.should be_assigned
-    @set.should include(0)
-    @set.should_not include(1,2)
+    @set.value.should include(0)
+    @set.value.should_not include(1,2)
   end
   
   it 'should constrain the elements of the set (constant parameter)' do
     @set.elements.must <= 0
     @model.solve!
     @set.should be_assigned
-    @set.should include(0)
-    @set.should_not include(1,2)
+    @set.value.should include(0)
+    @set.value.should_not include(1,2)
   end
   
   it_should_behave_like 'non-reifiable set constraint'

data/specs/constraints/sort.rb

@@ -31,12 +31,12 @@ describe Gecode::Constraints::IntEnum::Sort, ' (without :as and :order)' do
     @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::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::Space), 
           an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
           an_instance_of(Gecode::Raw::IntVar), 
           an_instance_of(Gecode::Raw::BoolVar), strength)
@@ -51,14 +51,14 @@ describe Gecode::Constraints::IntEnum::Sort, ' (without :as and :order)' do
 
   it 'should constraint variables to be sorted' do
     @vars.must_be.sorted
-    values = @model.solve!.vars.map{ |x| x.val }
+    values = @model.solve!.vars.values
     values.should == values.sort
   end
   
   it 'should allow negation' do
     @vars.must_not_be.sorted
     @model.solve!
-    values = @vars.map{ |x| x.val }
+    values = @vars.values
     values.should_not == values.sort
   end
   
@@ -79,7 +79,8 @@ describe Gecode::Constraints::IntEnum::Sort, ' (with :as)' do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:sortedness).once.with(@model.active_space, 
+      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
@@ -93,7 +94,7 @@ describe Gecode::Constraints::IntEnum::Sort, ' (with :as)' do
   it 'should constraint variables to be sorted' do
     @vars.must_be.sorted(:as => @sorted)
     @model.solve!
-    values = @sorted.map{ |x| x.val }
+    values = @sorted.values
     values.should == values.sort
   end
   
@@ -124,7 +125,8 @@ describe Gecode::Constraints::IntEnum::Sort, ' (with :order)' do
       @model.solve!
     end
     @expect_options = lambda do |strength, reif_var|
-      Gecode::Raw.should_receive(:sortedness).once.with(@model.active_space, 
+      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)
@@ -145,10 +147,10 @@ describe Gecode::Constraints::IntEnum::Sort, ' (with :order)' do
   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 = @sorted.values
     sorted_values.should == sorted_values.sort
-    expected_indices = @vars.map{ |v| sorted_values.index(v.val) }
-    @indices.map{ |i| i.val }.should == expected_indices
+    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

data/specs/enum_wrapper.rb

@@ -68,7 +68,9 @@ describe Gecode::IntEnumMethods do
   end
   
   it 'should convert to an int var array' do
-    @int_enum.to_int_var_array.should be_kind_of(Gecode::Raw::IntVarArray)
+    @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
@@ -84,7 +86,9 @@ describe Gecode::BoolEnumMethods do
   end
   
   it 'should convert to a bool var array' do
-    @bool_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+    @model.allow_space_access do
+      @bool_enum.to_bool_var_array.should be_kind_of(Gecode::Raw::BoolVarArray)
+    end
   end
 end
 
@@ -95,7 +99,9 @@ describe Gecode::SetEnumMethods do
   end
   
   it 'should convert to a set var array' do
-    @set_enum.to_set_var_array.should be_kind_of(Gecode::Raw::SetVarArray)
+    @model.allow_space_access do
+      @set_enum.to_set_var_array.should be_kind_of(Gecode::Raw::SetVarArray)
+    end
   end
 end
 

data/specs/int_var.rb

@@ -15,13 +15,13 @@ describe 'non-empty int variable', :shared => true do
   
   it 'should contain every element in its domain' do 
     @domain.each do |i|
-      @var.should be_in(i)
+      @var.should include(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)
+    @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
@@ -54,6 +54,10 @@ describe Gecode::FreeIntVar, ' (with range domain of size > 1)' do
   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
@@ -85,7 +89,7 @@ describe Gecode::FreeIntVar, ' (with non-range domain of size > 1)' do
   end
   
   it 'should not contain the domain\'s holes' do
-    @var.should_not be_in(0)
+    @var.should_not include(0)
   end
 end
 

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

@@ -116,13 +116,13 @@ describe Gecode::Model, ' (set creation)' do
   
   it 'should allow the creation of set variables with specified lower cardinality bound' do
     @model.set_var(@glb_range, @lub_range, 
-      @lower_card).card_min.should >= @lower_card
+      @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.card_max.should <= @upper_card
-    var.card_min.should >= @lower_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
@@ -130,8 +130,8 @@ describe Gecode::Model, ' (set creation)' do
     arr.size.should == 3
     arr.each do |var|
       var.should have_bounds(@glb_enum, @lub_enum)
-      var.card_max.should <= @upper_card
-      var.card_min.should >= @lower_card
+      var.cardinality.end.should <= @upper_card
+      var.cardinality.begin.should >= @lower_card
     end
   end
   
@@ -142,8 +142,8 @@ describe Gecode::Model, ' (set creation)' do
     matrix.column_size.should == 5
     matrix.each do |var|
       var.should have_bounds(@glb_enum, @lub_enum)
-      var.card_max.should <= @upper_card
-      var.card_min.should >= @lower_card
+      var.cardinality.end.should <= @upper_card
+      var.cardinality.begin.should >= @lower_card
     end
   end
   
@@ -161,4 +161,22 @@ describe Gecode::Model, ' (set creation)' 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

@@ -19,6 +19,20 @@ class SampleProblem < Gecode::Model
   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
+
 describe Gecode::Model, ' (with multiple solutions)' do
   before do
     @domain = 0..3
@@ -45,7 +59,7 @@ describe Gecode::Model, ' (with multiple solutions)' do
   it 'should pass every solution to #each_solution' do
     solutions = []
     @model.each_solution do |s|
-      solutions << s.var.val
+      solutions << s.var.value
     end
     Set.new(solutions).should == Set.new([2,3])
   end
@@ -143,6 +157,10 @@ describe Gecode::Model, ' (without solution)' do
   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
@@ -154,4 +172,26 @@ describe Gecode::Model, ' (without constraints)' do
   it 'should produce a solution' do
     @model.solve!.should_not be_nil
   end
+end
+
+describe Gecode::Model, '(optimization search)' do
+  before do
+    @model = SampleOptimizationProblem.new
+  end
+  
+  it 'should optimize the solution' do
+    solution = @model.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 raise error if no constrain proc has been defined' do
+    lambda do 
+      Gecode::Model.constrain(nil, nil) 
+    end.should raise_error(NotImplementedError)
+  end
 end