gecoder 0.8.2 → 0.8.3

data/lib/gecoder/interface/model.rb

@@ -1,117 +1,109 @@
 module Gecode
   # Model is the base class that all models must inherit from.
   class Model
+    # The largest integer allowed in the domain of an integer variable.
+    MAX_INT = Gecode::Raw::IntLimits::MAX
+    # The smallest integer allowed in the domain of an integer variable.
+    MIN_INT = Gecode::Raw::IntLimits::MIN
+
+    # The largest integer allowed in the domain of a set variable.
+    SET_MAX_INT = Gecode::Raw::SetLimits::MAX
+    # The smallest integer allowed in the domain of a set variable.
+    SET_MIN_INT = Gecode::Raw::SetLimits::MIN
+
+    # The largest possible domain for an integer variable.
+    LARGEST_INT_DOMAIN = MIN_INT..MAX_INT
+    # The largest possible domain, without negative integers, for an
+    # integer variable.
+    NON_NEGATIVE_INT_DOMAIN = 0..MAX_INT
+
+    # The largest possible bound for a set variable.
+    LARGEST_SET_BOUND = SET_MIN_INT..SET_MAX_INT
+
     # Creates a new integer variable with the specified domain. The domain can
     # either be a range, a single element, or an enumeration of elements. If no
     # domain is specified then the largest possible domain is used.
-    def int_var(domain = 
-        Gecode::Raw::IntLimits::MIN..Gecode::Raw::IntLimits::MAX)
-      enum = domain_enum(domain)
-      index = variable_creation_space.new_int_vars(enum).first
-      FreeIntVar.new(self, index)
+    def int_var(domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
     end
     
     # Creates an array containing the specified number of integer variables 
     # with the specified domain. The domain can either be a range, a single 
-    # element, or an enumeration of elements. 
-    def int_var_array(count, domain)
-      enum = domain_enum(domain)
-      variables = []
-      variable_creation_space.new_int_vars(enum, count).each do |index|
-        variables << FreeIntVar.new(self, index)
+    # element, or an enumeration of elements. If no domain is specified then 
+    # the largest possible domain is used.
+    def int_var_array(count, domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      build_var_array(count) do
+        FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number rows and columns of 
     # integer variables with the specified domain. The domain can either be a 
-    # range, a single element, or an enumeration of elements. 
-    def int_var_matrix(row_count, col_count, domain)
-      enum = domain_enum(domain)
-      indices = variable_creation_space.new_int_vars(enum, row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeIntVar.new(self, index)
-        end
+    # range, a single element, or an enumeration of elements. If no domain 
+    # is specified then the largest possible domain is used.
+    def int_var_matrix(row_count, col_count, domain = LARGEST_INT_DOMAIN)
+      args = domain_arguments(domain)
+      build_var_matrix(row_count, col_count) do
+        FreeIntVar.new(self, variable_creation_space.new_int_var(*args))
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Creates a new boolean variable.
     def bool_var
-      index = variable_creation_space.new_bool_vars.first
-      FreeBoolVar.new(self, index)
+      FreeBoolVar.new(self, variable_creation_space.new_bool_var)
     end
     
     # Creates an array containing the specified number of boolean variables.
     def bool_var_array(count)
-      variables = []
-      variable_creation_space.new_bool_vars(count).each do |index|
-        variables << FreeBoolVar.new(self, index)
+      build_var_array(count) do
+        FreeBoolVar.new(self, variable_creation_space.new_bool_var)
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number rows and columns of 
     # boolean variables.
     def bool_var_matrix(row_count, col_count)
-      indices = variable_creation_space.new_bool_vars(row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeBoolVar.new(self, index)
-        end
+      build_var_matrix(row_count, col_count) do
+        FreeBoolVar.new(self, variable_creation_space.new_bool_var)
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Creates a set variable with the specified domain for greatest lower bound
     # and least upper bound (specified as either a fixnum, range or enum). If 
-    # no bounds are specified then the empty set is used as greates lower bound 
-    # and the universe as least upper bound. A range for the allowed cardinality
-    # of the set can also be specified, if none is specified, or nil is given, 
-    # then the default range (anything) will be used. If only a single Fixnum is 
+    # no bounds are specified then the empty set is used as greatest lower 
+    # bound and the largest possible set as least upper bound. 
+    #
+    # A range for the allowed cardinality of the set can also be
+    # specified, if none is specified, or nil is given, then the default
+    # range (anything) will be used. If only a single Fixnum is
     # specified as cardinality_range then it's used as lower bound.
-    def set_var(glb_domain = [], lub_domain = 
-        Gecode::Raw::SetLimits::MIN..Gecode::Raw::SetLimits::MAX, 
+    def set_var(glb_domain = [], lub_domain = LARGEST_SET_BOUND,
         cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      index = variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-        to_set_cardinality_range(cardinality_range)).first
-      FreeSetVar.new(self, index)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
     end
     
     # Creates an array containing the specified number of set variables. The
     # parameters beyond count are the same as for #set_var .
-    def set_var_array(count, glb_domain, lub_domain, cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      variables = []
-      variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-          to_set_cardinality_range(cardinality_range), count).each do |index|
-        variables << FreeSetVar.new(self, index)
+    def set_var_array(count, glb_domain = [], lub_domain = LARGEST_SET_BOUND, 
+        cardinality_range = nil)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      build_var_array(count) do
+        FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
       end
-      return wrap_enum(variables)
     end
     
     # Creates a matrix containing the specified number of rows and columns 
     # filled with set variables. The parameters beyond row and column counts are
     # the same as for #set_var .
-    def set_var_matrix(row_count, col_count, glb_domain, lub_domain, 
-        cardinality_range = nil)
-      check_set_bounds(glb_domain, lub_domain)
-      
-      indices = variable_creation_space.new_set_vars(glb_domain, lub_domain, 
-        to_set_cardinality_range(cardinality_range), row_count*col_count)
-      rows = []
-      row_count.times do |i|
-        rows << indices[(i*col_count)...(i.succ*col_count)].map! do |index|
-          FreeSetVar.new(self, index)
-        end
+    def set_var_matrix(row_count, col_count, glb_domain = [], 
+        lub_domain = LARGEST_SET_BOUND, cardinality_range = nil)
+      args = set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      build_var_matrix(row_count, col_count) do
+        FreeSetVar.new(self, variable_creation_space.new_set_var(*args))
       end
-      return wrap_enum(Util::EnumMatrix.rows(rows, false))
     end
     
     # Retrieves the currently used space. Calling this method is only allowed 
@@ -176,20 +168,49 @@ module Gecode
     
     private
     
-    # Returns an enumeration of the specified domain arguments, which can 
-    # either be given as a range, a single number, or an enumerable of elements. 
-    def domain_enum(domain)
+    # Creates an array containing the specified number of variables, all
+    # constructed using the provided block..
+    def build_var_array(count, &block)
+      variables = []
+      count.times do 
+        variables << yield
+      end
+      return wrap_enum(variables)
+    end
+    
+    # Creates a matrix containing the specified number rows and columns of 
+    # variables, all constructed using the provided block. 
+    def build_var_matrix(row_count, col_count, &block)
+      rows = []
+      row_count.times do |i|
+        row = []
+        col_count.times do |j|
+          row << yield
+        end
+        rows << row
+      end
+      return wrap_enum(Util::EnumMatrix.rows(rows, false))
+    end
+
+    # Returns the array of arguments that correspond to the specified 
+    # domain when given to Gecode. The domain can be given as a range, 
+    # a single number, or an enumerable of elements. 
+    def domain_arguments(domain)
       if domain.respond_to?(:first) and domain.respond_to?(:last) and
             domain.respond_to?(:exclude_end?)
         if domain.exclude_end?
-          return domain.first..(domain.last - 1)
+          return [domain.first, (domain.last - 1)]
         else
-          return domain
+          return [domain.first, domain.last]
         end
       elsif domain.kind_of? Enumerable
-        return domain
+        array = domain.to_a
+        return [Gecode::Raw::IntSet.new(array, array.size)]
+      elsif domain.kind_of? Fixnum
+        return [domain, domain]
       else
-        return domain..domain
+        raise TypeError, 'The domain must be given as an instance of ' +
+          "Enumerable or Fixnum, but #{domain.class} was given."
       end
     end
     
@@ -204,6 +225,21 @@ module Gecode
       end
     end
     
+    # Converts the specified set var domain to parameters accepted by
+    # Gecode. The bounds can be specified as a fixnum, range or # enum. 
+    # The parameters are returned as an array.
+    def set_bounds_to_parameters(glb_domain, lub_domain, cardinality_range)
+      check_set_bounds(glb_domain, lub_domain)
+      args = []
+      args << Gecode::Constraints::Util.constant_set_to_int_set(glb_domain)
+      args << Gecode::Constraints::Util.constant_set_to_int_set(lub_domain)
+      card_range = to_set_cardinality_range(cardinality_range)
+      if card_range.nil?
+        card_range = 0..Gecode::Raw::SetLimits::CARD
+      end
+      args << card_range.first << card_range.last
+    end
+    
     # Checks whether the specified greatest lower bound is a subset of least 
     # upper bound. Raises ArgumentError if that is not the case.
     def check_set_bounds(glb, lub)
@@ -243,15 +279,6 @@ module Gecode
       @variable_creation_space || selected_space
     end
     
-    # Refreshes all cached variables. This should be called if the variables
-    # in an existing space were changed.
-    def refresh_variables
-      return if @variables.nil?
-      @variables.each do |variable|
-        variable.refresh if variable.cached?
-      end
-    end
-    
     # Executes any interactions with Gecode still waiting in the queue 
     # (emptying the queue) in the process.
     def perform_queued_gecode_interactions
@@ -266,8 +293,6 @@ module Gecode
     # assigned directly.
     def active_space=(new_space)
       @active_space = new_space
-      new_space.refresh
-      refresh_variables
     end    
   end
-end
+end

data/lib/gecoder/interface/variables.rb

@@ -8,21 +8,9 @@ module Gecode
     def initialize(model, index)
       @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}>"
@@ -54,13 +42,7 @@ module Gecode
       # Binds the int variable to the currently active space of the model, 
       # returning the bound int variable.
       def bind
-        space = active_space
-        unless @bound_space == space
-          # We have not bound the variable to this space, so we do it now.
-          @bound = space.method(:#{space_bind_method}).call(@index)
-          @bound_space = space
-        end
-        return @bound
+        active_space.method(:#{space_bind_method}).call(@index)
       end
       
       private
@@ -251,4 +233,4 @@ module Gecode
       end
     end
   end
-end
+end

data/lib/gecoder/version.rb

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

data/specs/branch.rb

@@ -37,6 +37,16 @@ describe Gecode::Model, ' (integer branch)' do
     @model.solve!.bools.each{ |var| var.should be_assigned }
   end
 
+  it 'should allow branching on a single integer variable' do
+    @model.branch_on @vars.first
+    @model.solve!.vars.first.should be_assigned
+  end
+
+  it 'should allow branching on a single boolean variable' do
+    @model.branch_on @bools.first
+    @model.solve!.bools.first.should be_assigned
+  end
+
   supported_var_selectors = {
     :none                 => Gecode::Raw::INT_VAR_NONE,
     :smallest_min         => Gecode::Raw::INT_VAR_MIN_MIN,
@@ -120,6 +130,11 @@ describe Gecode::Model, ' (set branch)' do
     @model.branch_on @sets
     @model.solve!.sets.each{ |var| var.should be_assigned }
   end
+  
+  it 'should allow branching on a single set variable' do
+    @model.branch_on @sets.first
+    @model.solve!.sets.first.should be_assigned
+  end
 
   supported_var_selectors = {
     :none                 => Gecode::Raw::SET_VAR_NONE,
@@ -167,4 +182,4 @@ describe Gecode::Model, ' (set branch)' do
       @model.branch_on @sets, :foo => 5 
     end.should raise_error(ArgumentError)
   end
-end
+end

data/specs/constraints/bool_enum_relation.rb

@@ -15,8 +15,8 @@ class BoolEnumSampleProblem < Gecode::Model
   end
 end
 
-# Expects @stub, which contains the started constraint and @compute_result which 
-# computes whether the left hand side is true or not.
+# Expects @stub, which contains the started constraint and @compute_result 
+# which computes whether the left hand side is true or not.
 describe 'bool enum relation constraint', :shared => true do
   it 'should handle being constrained to be true' do
     @stub.must_be.true
@@ -76,7 +76,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (conjunction)' do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      @bools.conjunction.must_be.equal_to(true, hash) 
+      @bools.conjunction.must.equal(@b1, hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
@@ -94,7 +94,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (conjunction)' do
             an_instance_of(Gecode::Raw::BoolVar),
             anything,
             an_instance_of(Gecode::Raw::BoolVar),
-            anything, anything, anything)
+            anything, anything)
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             Gecode::Raw::BOT_AND, 
@@ -122,7 +122,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (disjunction)' do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      @bools.disjunction.must_be.equal_to(true, hash) 
+      @bools.disjunction.must.equal(@b1, hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
@@ -140,7 +140,7 @@ describe Gecode::Constraints::BoolEnum::Relation, ' (disjunction)' do
             an_instance_of(Gecode::Raw::BoolVar),
             anything,
             an_instance_of(Gecode::Raw::BoolVar),
-            anything, anything, anything)          
+            anything, anything)          
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
             Gecode::Raw::BOT_OR, 

data/specs/constraints/boolean.rb

@@ -22,28 +22,22 @@ describe Gecode::Constraints::Bool do
     
     # For constraint option spec.
     @invoke_options = lambda do |hash| 
-      (@b1 | @b2).must_be.equal_to(true, hash) 
+      (@b1 | @b2).must_be.true(hash) 
       @model.solve!
     end
     @expect_options = option_expectation do |strength, kind, reif_var|
       @model.allow_space_access do
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::BoolVar),
-          Gecode::Raw::BOT_OR, 
-          an_instance_of(Gecode::Raw::BoolVar), 
-          an_instance_of(Gecode::Raw::BoolVar),
-          Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
+        # We only test the non-MiniModel parts.
         unless reif_var.nil?
           Gecode::Raw.should_receive(:rel).once.with(
             an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::BOT_EQV, 
-            an_instance_of(Gecode::Raw::BoolVar), 1, strength, kind)
+            an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::IRT_EQ, 
+            an_instance_of(Gecode::Raw::BoolVar), strength, kind)
         end
       end
     end
   end
-  
+
   it 'should handle single variables constrainted to be true' do
     @b1.must_be.true
     b1 = @model.solve!.b1
@@ -79,7 +73,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should be_true
   end
-  
+
   it 'should handle negated disjunction' do
     @b1.must_be.false
     (@b1 | @b2).must_not_be.true
@@ -87,7 +81,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle conjunction' do
     (@b1 & @b2).must_be.true
     sol = @model.solve!
@@ -142,7 +136,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle imply after must_not' do
     @b1.must_be.true
     @b1.must_not.imply @b2
@@ -166,7 +160,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should be_true
     sol.b2.value.should_not be_true
   end
-  
+
   it 'should handle expressions as right hand side' do
     @b1.must == (@b2 | @b3)
     @b2.must_be.true
@@ -174,7 +168,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should be_true
     sol.b2.value.should be_true
   end
-  
+
   it 'should handle nested expressions as left hand side' do
     ((@b1 & @b2) | @b3 | (@b1 & @b3)).must_be.true
     @b1.must_be.false
@@ -182,7 +176,7 @@ describe Gecode::Constraints::Bool do
     sol.b1.value.should_not be_true
     sol.b3.value.should be_true
   end
-  
+
   it 'should handle nested expressions on both side' do
     ((@b1 & @b1) | @b3).must == ((@b1 & @b3) & @b2)
     @b1.must_be.true
@@ -191,7 +185,15 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should be_true
     sol.b3.value.should be_true
   end
-  
+
+  it 'should handle nested expressions with implication' do
+    ((@b1 & @b1) | @b3).must.imply(@b1 ^ @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_false
+  end
+
   it 'should handle nested expressions containing exclusive or' do
     ((@b1 ^ @b1) & @b3).must == ((@b2 | @b3) ^ @b2)
     @b1.must_be.true
@@ -201,7 +203,7 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should_not be_true
     sol.b3.value.should_not be_true
   end
-  
+
   it 'should handle nested expressions on both sides with negation' do
     ((@b1 & @b1) | @b3).must_not == ((@b1 | @b3) & @b2)
     @b1.must_be.true
@@ -211,7 +213,7 @@ describe Gecode::Constraints::Bool do
     sol.b2.value.should_not be_true
     sol.b3.value.should be_true
   end
-  
+
   it 'should translate reification with a variable right hand side' do
     @b1.must_be.equal_to(@b2, :reify => @b3)
     @b1.must_be.true
@@ -219,8 +221,8 @@ describe Gecode::Constraints::Bool do
     sol = @model.solve!
     sol.b3.value.should_not be_true
   end
-  
-  it 'should translate reification with a variable right hand side and negation' do
+
+  it 'should translate reification with a variable right hand side and negation'  do
     @b1.must_not_be.equal_to(@b2, :reify => @b3)
     @b1.must_be.true
     @b2.must_be.false
@@ -228,9 +230,13 @@ describe Gecode::Constraints::Bool do
     sol.b3.value.should be_true
   end
   
-  it 'should raise error on right hand sides of the wrong type' do
+  it 'should raise error on right hand sides of incorrect type given to #==' do
     lambda{ @b1.must == 'hello' }.should raise_error(TypeError) 
   end
-  
+
+  it 'should raise error on right hand sides of incorrect type given to #imply' do
+    lambda{ @b1.must.imply 'hello' }.should raise_error(TypeError) 
+  end
+
   it_should_behave_like 'reifiable constraint'
-end
+end