gecoder 0.6.0 → 0.6.1

data/lib/gecoder/interface/search.rb

@@ -4,7 +4,9 @@ module Gecode
     # to that solution. Returns the model if a solution was found, nil 
     # otherwise.
     def solve!
+      GC.disable
       space = dfs_engine.next
+      GC.enable
       return nil if space.nil?
       @active_space = space
       return self
@@ -30,9 +32,11 @@ module Gecode
     # Yields each solution that the model has.
     def each_solution(&block)
       dfs = dfs_engine
+      GC.disable
       while not (@active_space = dfs.next).nil?
         yield self
       end
+      GC.enable
       self.reset!
     end
     
@@ -49,30 +53,46 @@ module Gecode
     #
     # Returns nil if there is no solution.
     def optimize!(&block)
-      next_space = nil
-      best_space = nil
-      bab = bab_engine
-      
+      # Execute constraints.
+      perform_queued_gecode_interactions
+
+      # Set the method used for constrain calls by the BAB-search.
       Model.constrain_proc = lambda do |home_space, best_space|
         @active_space = best_space
+        @variable_creation_space = home_space
         yield(self, self)
         @active_space = home_space
+        @variable_creation_space = nil
+        
         perform_queued_gecode_interactions
       end
+
+      # Perform the search.
+      GC.disable
+      result = Gecode::Raw::bab(selected_space, 
+        Gecode::Raw::Search::Config::MINIMAL_DISTANCE, 
+        Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
+        nil)
+      GC.enable
       
-      while not (next_space = bab.next).nil?
-        best_space = next_space
-      end
+      # Reset the method used constrain calls and return the result.
       Model.constrain_proc = nil
-      return nil if best_space.nil?
+      return nil if result.nil?
+      
+      # Refresh the solution.
+      result.refresh
+      refresh_variables
+      @active_space = result
       return self
     end
     
     class <<self
+      # Sets the proc that should be used to handle constrain requests.
       def constrain_proc=(proc)
         @constrain_proc = proc
       end
     
+      # Called by spaces when they want to constrain as part of BAB-search.
       def constrain(home, best)
         if @constrain_proc.nil?
           raise NotImplementedError, 'Constrain method not implemented.' 
@@ -91,25 +111,10 @@ module Gecode
       perform_queued_gecode_interactions
       
       # Construct the engine.
-      stop = Gecode::Raw::Search::Stop.new
       Gecode::Raw::DFS.new(selected_space, 
         Gecode::Raw::Search::Config::MINIMAL_DISTANCE,
         Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
-        stop)
-    end
-    
-    # Creates a branch and bound engine for optimization search, executing any 
-    # unexecuted constraints first.
-    def bab_engine
-      # Execute constraints.
-      perform_queued_gecode_interactions
-      
-      # Construct the engine.
-      stop = Gecode::Raw::Search::Stop.new
-      Gecode::Raw::BAB.new(selected_space, 
-        Gecode::Raw::Search::Config::MINIMAL_DISTANCE,
-        Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
-        stop)
+        nil)
     end
     
     # Executes any interactions with Gecode still waiting in the queue 

data/lib/gecoder/interface/variables.rb

@@ -8,6 +8,26 @@ module Gecode
       @model = model
       @index = index
       @bound_space = @bound_var = nil
+      model.track_variable(self)
+    end
+    
+    # Checks whether the variable is cached, i.e. whether it needs to be 
+    # rebound after changes to a space.
+    def cached?
+      not @bound_space.nil?
+    end
+    
+    # Forces the variable to refresh itself.
+    def refresh
+      @bound_space = nil
+    end
+    
+    def inspect
+      if assigned?
+        "#<#{self.class} #{domain}>"
+      else
+        "#<#{self.class} #{domain}>"
+      end
     end
     
     private
@@ -16,6 +36,13 @@ module Gecode
     def active_space
       @model.active_space
     end
+    
+    # Sends the specified method name and arguments to the bound variable.
+    def send_bound(method_name, *args)
+      @model.allow_space_access do
+        bind.send(method_name, *args)
+      end
+    end
   end
   
   # Creates a class for a free variable that can be bound into the specified
@@ -35,14 +62,6 @@ module Gecode
         return @bound
       end
       
-      def inspect
-        if assigned?
-          "#<\#{self.class} \#{domain}>"
-        else
-          "#<\#{self.class} \#{domain}>"
-        end
-      end
-      
       private
       
       # Delegates the method with the specified name to a method with the 
@@ -58,13 +77,6 @@ module Gecode
           end
         end_code
       end
-      
-      # Sends the specified method name and arguments to the bound variable.
-      def send_bound(method_name, *args)
-        @model.allow_space_access do
-          bind.send(method_name, *args)
-        end
-      end
     end_method_definitions
     return clazz
   end

data/lib/gecoder/version.rb

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

data/specs/constraints/arithmetic.rb

@@ -65,10 +65,10 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:max).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
@@ -89,7 +89,8 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
             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,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -114,10 +115,10 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
        if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:min).once.with(
               an_instance_of(Gecode::Raw::Space), 
               an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
@@ -138,7 +139,8 @@ describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
             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,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -163,18 +165,19 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:abs).once.with(
               an_instance_of(Gecode::Raw::Space),
-              @var.bind, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 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)
+              an_instance_of(Gecode::Raw::IntVar), 
+              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)
@@ -182,7 +185,8 @@ describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
         else
           Gecode::Raw.should_receive(:abs).once.with(
             an_instance_of(Gecode::Raw::Space),
-            @var.bind, an_instance_of(Gecode::Raw::IntVar), strength)
+            an_instance_of(Gecode::Raw::IntVar), 
+            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, 
@@ -212,18 +216,21 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
     # Creates an expectation corresponding to the specified input.
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:mult).once.with(
               an_instance_of(Gecode::Raw::Space),
-              @var.bind, @var2.bind, rhs, strength)
+              an_instance_of(Gecode::Raw::IntVar), 
+              an_instance_of(Gecode::Raw::IntVar), 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), 
+              an_instance_of(Gecode::Raw::IntVar), 
+              an_instance_of(Gecode::Raw::IntVar), 
+              an_instance_of(Gecode::Raw::IntVar), 
               strength)
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -232,10 +239,13 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
         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)
+            an_instance_of(Gecode::Raw::IntVar), 
+            an_instance_of(Gecode::Raw::IntVar), 
+            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,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end

data/specs/constraints/bool_enum.rb

@@ -88,7 +88,8 @@ describe Gecode::Constraints::BoolEnum, ' (conjunction)' do
         unless reif_var.nil?
           Gecode::Raw.should_receive(:bool_eqv).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
         end
       end
     end
@@ -123,7 +124,8 @@ describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
         unless reif_var.nil?
           Gecode::Raw.should_receive(:bool_eqv).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
         end
       end
     end

data/specs/constraints/boolean.rb

@@ -29,12 +29,15 @@ describe Gecode::Constraints::Bool do
       @model.allow_space_access do
         Gecode::Raw.should_receive(:bool_or).once.with(
           an_instance_of(Gecode::Raw::Space), 
-          @b1.bind, @b2.bind, an_instance_of(Gecode::Raw::BoolVar), 
+          an_instance_of(Gecode::Raw::BoolVar), 
+          an_instance_of(Gecode::Raw::BoolVar), 
+          an_instance_of(Gecode::Raw::BoolVar), 
           Gecode::Raw::ICL_DEF)
         unless reif_var.nil?
           Gecode::Raw.should_receive(:bool_eqv).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), reif_var.bind, true, strength)
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
         end
       end
     end

data/specs/constraints/cardinality.rb

@@ -21,7 +21,7 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
       @model.allow_space_access do
         Gecode::Raw.should_receive(:cardinality).once.with(
           an_instance_of(Gecode::Raw::Space), 
-          @set.bind, rhs.first, rhs.last)
+          an_instance_of(Gecode::Raw::SetVar), rhs.first, rhs.last)
       end
     end
   end
@@ -47,7 +47,10 @@ describe Gecode::Constraints::Set::Cardinality, ' (range)' do
   end
   
   it 'should not shadow the integer variable domain constrain' do
-    Gecode::Raw.should_receive(:dom).once.with(
+    Gecode::Raw.should_receive(:dom).with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::IntVar), 0, 11, Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:dom).with(
       an_instance_of(Gecode::Raw::Space), 
       an_instance_of(Gecode::Raw::IntVar), an_instance_of(Gecode::Raw::IntSet), 
       an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
@@ -72,16 +75,18 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
     end
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:cardinality).once.with( 
-              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:cardinality).once.with(
-              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -91,10 +96,12 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
         else
           Gecode::Raw.should_receive(:cardinality).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs,
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -129,6 +136,19 @@ describe Gecode::Constraints::Set::Cardinality, ' (composite)' do
     @set.value.size.should == @var.value
   end
   
+  it 'should constrain the cardinality of a set (2)' do
+    @set.size.must == 2
+    @model.solve!.should_not be_nil
+    @set.value.size.should == 2
+  end
+
+  it 'should constrain the cardinality of a set (3)' do
+    @set.size.must == @var
+    @var.must == 2
+    @model.solve!
+    @set.value.size.should == 2
+  end
+  
   it_should_behave_like 'constraint with options'
   it_should_behave_like 'composite constraint'
 end

data/specs/constraints/connection.rb

@@ -46,16 +46,18 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
     
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:min).once.with( 
-              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+              an_instance_of(Gecode::Raw::Space),
+              an_instance_of(Gecode::Raw::SetVar), rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:min).once.with(
-              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -65,10 +67,12 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
         else
           Gecode::Raw.should_receive(:min).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -76,9 +80,9 @@ describe Gecode::Constraints::Set::Connection, ' (min)' do
   end
   
   it 'should constrain the min of a set' do
-    @set.min.must == @var
+    @set.min.must == 3
     @model.solve!
-    @set.lower_bound.min.should == @var.value
+    @set.lower_bound.min.should == 3
   end
   
   it_should_behave_like 'connection constraint'
@@ -94,16 +98,18 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
     
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:max).once.with( 
-              an_instance_of(Gecode::Raw::Space), @set.bind, rhs)
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:max).once.with(
-              an_instance_of(Gecode::Raw::Space), @set.bind, 
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -113,10 +119,12 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
         else
           Gecode::Raw.should_receive(:max).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -124,9 +132,9 @@ describe Gecode::Constraints::Set::Connection, ' (max)' do
   end
   
   it 'should constrain the max of a set' do
-    @set.max.must == @var
+    @set.max.must == 3
     @model.solve!
-    @set.lower_bound.max.should == @var.value
+    @set.lower_bound.max.should == 3
   end
   
   it_should_behave_like 'connection constraint'
@@ -142,17 +150,19 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
     
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), 
               rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -162,10 +172,12 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
         else
           Gecode::Raw.should_receive(:weights).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -173,9 +185,9 @@ describe Gecode::Constraints::Set::Connection, ' (sum)' do
   end
   
   it 'should constrain the sum of a set' do
-    @set.sum.must == @var
+    @set.sum.must == 7
     @model.solve!.should_not be_nil
-    @set.value.inject(0){ |x, y| x + y }.should == @var.value
+    @set.value.inject(0){ |x, y| x + y }.should == 7
   end
   
   it 'should raise error if unsupported options is given' do
@@ -204,16 +216,18 @@ describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
     
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, rhs)
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -223,10 +237,12 @@ describe Gecode::Constraints::Set::Connection, ' (sum with weights)' do
         else
           Gecode::Raw.should_receive(:weights).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -261,16 +277,18 @@ describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
     
     @expect = lambda do |relation, rhs, strength, reif_var, negated|
       @model.allow_space_access do
-        rhs = rhs.bind if rhs.respond_to? :bind
+        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
         if reif_var.nil?
           if !negated and relation == Gecode::Raw::IRT_EQ and 
-              rhs.kind_of? Gecode::Raw::IntVar 
+              !rhs.kind_of? Fixnum
             Gecode::Raw.should_receive(:weights).once.with( 
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, rhs)
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), rhs)
             Gecode::Raw.should_receive(:rel).exactly(0).times
           else
             Gecode::Raw.should_receive(:weights).once.with(
-              an_instance_of(Gecode::Raw::Space), anything, anything, @set.bind, 
+              an_instance_of(Gecode::Raw::Space), anything, anything, 
+              an_instance_of(Gecode::Raw::SetVar), 
               an_instance_of(Gecode::Raw::IntVar))
             Gecode::Raw.should_receive(:rel).once.with(
               an_instance_of(Gecode::Raw::Space), 
@@ -280,10 +298,12 @@ describe Gecode::Constraints::Set::Connection, ' (sum with substitutions)' do
         else
           Gecode::Raw.should_receive(:weights).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            anything, anything, @set.bind, an_instance_of(Gecode::Raw::IntVar))
+            anything, anything, an_instance_of(Gecode::Raw::SetVar), 
+            an_instance_of(Gecode::Raw::IntVar))
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, reif_var.bind,
+            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+            an_instance_of(Gecode::Raw::BoolVar),
             strength)
         end
       end
@@ -314,7 +334,8 @@ describe Gecode::Constraints::Set::Connection, ' (include)' do
       @model.allow_space_access do
         Gecode::Raw.should_receive(:match).once.with(
           an_instance_of(Gecode::Raw::Space), 
-          @set.bind, an_instance_of(Gecode::Raw::IntVarArray))
+          an_instance_of(Gecode::Raw::SetVar), 
+          an_instance_of(Gecode::Raw::IntVarArray))
       end
     end