gecoder 0.5.0 → 0.6.0

data/lib/gecoder/version.rb

@@ -1,4 +1,4 @@
 module GecodeR
   # A string representation of the Gecode/R version.
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/specs/binding_changes.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe 'Space', :shared => true do
   it 'should give different indices when creating int variables' do
-    @space.new_int_vars(0, 17).should_not equal(@space.new_int_vars(0, 17))
+    @space.new_int_vars([0, 17]).should_not equal(@space.new_int_vars([0, 17]))
   end
   
   it 'should give different indices when creating bool variables' do
@@ -10,7 +10,7 @@ describe 'Space', :shared => true do
   end
   
   it 'should give different indices when creating multiple int variables' do
-    @space.new_int_vars(0, 17, 17).uniq.size.should equal(17)
+    @space.new_int_vars([0, 17], 17).uniq.size.should equal(17)
   end
   
   it 'should give different indices when creating multiple bool variables' do
@@ -18,7 +18,7 @@ describe 'Space', :shared => true do
   end
   
   it 'should not return nil for created int variables' do
-    @space.new_int_vars(0, 17, 4).each do |i|
+    @space.new_int_vars([0, 17], 4).each do |i|
       @space.int_var(i).should_not be_nil
     end
   end
@@ -36,6 +36,10 @@ describe 'Space', :shared => true do
   it 'should return nil when requesting bool variables with negative indices' do
     @space.bool_var(-1).should be_nil
   end
+  
+  it 'should raise an error if given a domain of incorrect type' do
+    lambda{ @space.new_int_vars(17) }.should raise_error(TypeError)
+  end
 end
 
 describe Gecode::Raw::Space, ' (new)' do
@@ -57,8 +61,8 @@ end
 describe Gecode::Raw::Space, ' (with items)' do
   before do
     @space = Gecode::Raw::Space.new
-    @first = @space.new_int_vars(1, 4).first
-    @second = @space.new_int_vars(-5, 5).first
+    @first = @space.new_int_vars([1, 4]).first
+    @second = @space.new_int_vars([-5, 5]).first
   end
   
   it_should_behave_like 'Space'

data/specs/bool_var.rb

@@ -21,6 +21,10 @@ describe Gecode::FreeBoolVar, '(not assigned)' do
   it "should say that it's not assigned when inspecting" do
     @var.inspect.should include('unassigned')
   end
+  
+  it 'should raise error when trying to access assigned value' do
+    lambda{ @var.value }.should raise_error(RuntimeError)
+  end
 end
 
 describe Gecode::FreeBoolVar, '(assigned true)' do
@@ -37,12 +41,8 @@ describe Gecode::FreeBoolVar, '(assigned true)' do
     @var.should be_assigned
   end
   
-  it 'should respond true to true?' do
-    @var.true?.should be_true
-  end
-  
-  it 'should not respond true to false?' do
-    @var.false?.should_not be_true
+  it 'should have valye true' do
+    @var.value.should be_true
   end
   
   it "should say that it's true when inspecting" do
@@ -64,12 +64,8 @@ describe Gecode::FreeBoolVar, '(assigned false)' do
     @var.should be_assigned
   end
   
-  it 'should respond not true to true?' do
-    @var.true?.should_not be_true
-  end
-  
-  it 'should respond true to false?' do
-    @var.false?.should be_true
+  it 'should have value false ' do
+    @var.value.should_not be_true
   end
   
   it "should say that it's false when inspecting" do

data/specs/branch.rb

@@ -3,39 +3,28 @@ require File.dirname(__FILE__) + '/spec_helper'
 class BranchSampleProblem < Gecode::Model
   attr :vars
   attr :bools
+  attr :sets
   
   def initialize
     @vars = int_var_array(2, 0..3)
+    @sets = set_var_array(2, [], 0..4)
     @bools = bool_var_array(2)
   end
 end
 
-describe Gecode::Model, ' (branch)' do
+describe Gecode::Model, ' (integer branch)' do
   before do
     @model = BranchSampleProblem.new
     @vars = @model.vars
     @bools = @model.bools
   end
 
-  it 'should pass the variables given in int arrays' do
-    Gecode::Raw.should_receive(:branch).once.and_return{ |s, vars, x, y| vars }
-    int_var_array = @model.branch_on @vars
-    int_var_array.size.should equal(2)
-    2.times do |i|
-      int_var_array.at(i).should have_domain(0..3)
-    end
-  end
-  
-  it 'should pass the variables given in bool arrays' do
-    Gecode::Raw.should_receive(:branch).once.and_return{ |s, vars, x, y| vars }
-    bool_var_array = @model.branch_on @bools
-    bool_var_array.size.should equal(2)
-  end
-
   it 'should default to :none and :min' do
-    Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+    Gecode::Raw.should_receive(:branch).once.with(
+      an_instance_of(Gecode::Raw::Space), 
       anything, Gecode::Raw::BVAR_NONE, Gecode::Raw::BVAL_MIN)
     @model.branch_on @vars
+    @model.solve!
   end
   
   it 'should ensure that branched int variables are assigned in a solution' do
@@ -64,9 +53,11 @@ describe Gecode::Model, ' (branch)' do
     :largest_max_regret   => Gecode::Raw::BVAR_REGRET_MAX_MAX
   }.each_pair do |name, gecode_const|
     it "should support #{name} as variable selection strategy" do
-      Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space),
         anything, gecode_const, an_instance_of(Numeric))
       @model.branch_on @vars, :variable => name
+      @model.solve!
     end
   end
 
@@ -78,9 +69,11 @@ describe Gecode::Model, ' (branch)' do
     :split_max  => Gecode::Raw::BVAL_SPLIT_MAX
   }.each_pair do |name, gecode_const|
     it "should support #{name} as value selection strategy" do
-      Gecode::Raw.should_receive(:branch).once.with(@model.active_space, 
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space), 
         anything, an_instance_of(Numeric), gecode_const)
       @model.branch_on @vars, :value => name
+      @model.solve!
     end
   end
 
@@ -101,4 +94,77 @@ describe Gecode::Model, ' (branch)' do
       @model.branch_on @vars, :foo => 5 
     end.should raise_error(ArgumentError)
   end
+  
+  it 'should raise errors for unrecognized enumerations' do
+    lambda do
+      @model.branch_on [1,2,3]
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Model, ' (set branch)' do
+  before do
+    @model = BranchSampleProblem.new
+    @sets = @model.sets
+  end
+
+  it 'should default to :none and :min' do
+    Gecode::Raw.should_receive(:branch).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, Gecode::Raw::SETBVAR_NONE, Gecode::Raw::SETBVAL_MIN)
+    @model.branch_on @sets
+    @model.solve!
+  end
+  
+  it 'should ensure that branched set variables are assigned in a solution' do
+    @model.branch_on @sets
+    @model.solve!.sets.each{ |var| var.should be_assigned }
+  end
+
+  supported_var_selectors = {
+    :none                 => Gecode::Raw::SETBVAR_NONE,
+    :smallest_cardinality => Gecode::Raw::SETBVAR_MIN_CARD,
+    :largest_cardinality  => Gecode::Raw::SETBVAR_MAX_CARD, 
+    :smallest_unknown     => Gecode::Raw::SETBVAR_MIN_UNKNOWN_ELEM, 
+    :largest_unknown      => Gecode::Raw::SETBVAR_MAX_UNKNOWN_ELEM
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as variable selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space),
+        anything, gecode_const, an_instance_of(Numeric))
+      @model.branch_on @sets, :variable => name
+      @model.solve!
+    end
+  end
+
+  supported_val_selectors = {
+    :min  => Gecode::Raw::SETBVAL_MIN,
+    :max  => Gecode::Raw::SETBVAL_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as value selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        anything, an_instance_of(Numeric), gecode_const)
+      @model.branch_on @sets, :value => name
+      @model.solve!
+    end
+  end
+
+  it 'should raise errors for unrecognized var selection strategies' do
+    lambda do 
+      @model.branch_on @sets, :variable => :foo 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized val selection strategies' do
+    lambda do 
+      @model.branch_on @sets, :value => :foo 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise errors for unrecognized options' do
+    lambda do
+      @model.branch_on @sets, :foo => 5 
+    end.should raise_error(ArgumentError)
+  end
 end

data/specs/constraints/arithmetic.rb

@@ -64,34 +64,41 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
-      rhs = rhs.bind if rhs.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            rhs.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:max).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:max).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
         else
-          Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
+          Gecode::Raw.should_receive(:max).once.with(
+            an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
             an_instance_of(Gecode::Raw::IntVar), strength)
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
         end
-      else
-        Gecode::Raw.should_receive(:max).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
-          strength)
       end
     end
   end
   
   it 'should constrain the maximum value' do
     @numbers.max.must > 5
-    @model.solve!.numbers.map{ |n| n.val }.max.should > 5
+    @model.solve!.numbers.values.max.should > 5
   end
   
   it_should_behave_like 'arithmetic constraint'
@@ -106,34 +113,41 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
-      rhs = rhs.bind if rhs.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            rhs.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+       if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:min).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:min).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
         else
-          Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
+          Gecode::Raw.should_receive(:min).once.with(
+            an_instance_of(Gecode::Raw::Space), 
             an_instance_of(Gecode::Raw::IntVarArray), 
             an_instance_of(Gecode::Raw::IntVar), strength)
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            strength)
         end
-      else
-        Gecode::Raw.should_receive(:min).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVarArray), 
-          an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
-          strength)
       end
     end
   end
   
   it 'should constrain the minimum value' do
     @numbers.min.must > 5
-    @model.solve!.numbers.map{ |n| n.val }.min.should > 5
+    @model.solve!.numbers.values.min.should > 5
   end
   
   it_should_behave_like 'arithmetic constraint'
@@ -148,25 +162,32 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
-      rhs = rhs.bind if rhs.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            rhs.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
-            @var.bind, rhs, strength)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:abs).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              @var.bind, rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:abs).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
         else
-          Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
+          Gecode::Raw.should_receive(:abs).once.with(
+            an_instance_of(Gecode::Raw::Space),
             @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar), strength)
         end
-      else
-        Gecode::Raw.should_receive(:abs).once.with(@model.active_space,
-          @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-          an_instance_of(Gecode::Raw::BoolVar), strength)
       end
     end
   end
@@ -174,7 +195,7 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
   it 'should constrain the absolute value' do
     @var.must < 0
     @var.abs.must == 5
-    @model.solve!.var.val.should == -5
+    @model.solve!.var.value.should == -5
   end
   
   it_should_behave_like 'arithmetic constraint'
@@ -190,26 +211,33 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
     
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
-      rhs = rhs.bind if rhs.respond_to? :bind
-      if reif_var.nil?
-        if !negated and relation == Gecode::Raw::IRT_EQ and 
-            rhs.kind_of? Gecode::Raw::IntVar 
-          Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
-            @var.bind, @var2.bind, rhs, strength)
-          Gecode::Raw.should_receive(:rel).exactly(0).times
+      @model.allow_space_access do
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          if !negated and relation == Gecode::Raw::IRT_EQ and 
+              rhs.kind_of? Gecode::Raw::IntVar 
+            Gecode::Raw.should_receive(:mult).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              @var.bind, @var2.bind, rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:mult).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), 
+              strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
         else
-          Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
-            @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), 
+          Gecode::Raw.should_receive(:mult).once.with(
+            an_instance_of(Gecode::Raw::Space),
+            @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), strength)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
             strength)
-          Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
         end
-      else
-        Gecode::Raw.should_receive(:mult).once.with(@model.active_space,
-          @var.bind, @var2.bind, an_instance_of(Gecode::Raw::IntVar), strength)
-        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
-          an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
-          strength)
       end
     end
   end
@@ -217,7 +245,7 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
   it 'should constrain the value of the multiplication' do
     (@var * @var2).must == 56
     sol = @model.solve!
-    [sol.var.val, sol.var2.val].sort.should == [7, 8]
+    [sol.var.value, sol.var2.value].sort.should == [7, 8]
   end
   
   it 'should not interfere with other defined multiplication methods' do