gecoder-with-gecode 0.8.2 → 0.8.3

data/lib/gecoder/interface/constraints/set/channel.rb

@@ -0,0 +1,54 @@
+module Gecode::Constraints::Set
+  class Expression
+    # Adds a channel constraint on the set variable with the specified enum of 
+    # boolean variables.
+    def channel(bool_enum, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraint does not support the ' + 
+          'reification option.'
+      end
+      unless bool_enum.respond_to? :to_bool_var_array
+        raise TypeError, 'Expected an enum of bool variables, ' + 
+          "got #{bool_enum.class}."
+      end
+      
+      @params.update(:rhs => bool_enum)
+      @params.update Gecode::Constraints::Set::Util.decode_options(options)
+      @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints
+  # involving one set variable and a boolean enum.
+  module Channel #:nodoc:
+    # Describes a channel constraint that "channels" a set variable and an
+    # enumerations of boolean variables. This constrains the set variable to
+    # include value i exactly when the variable at index i in the boolean
+    # enumeration is true.
+    # 
+    # Neither reification nor negation is supported. The boolean enum and set
+    # can be interchanged.
+    #
+    # == Examples
+    #
+    # # Constrains the enumeration of boolean variables called +bools+ to at
+    # # least have the first and third variables set to true 
+    # set.must_be.superset_of [0, 2]
+    # set.must.channel bools
+    #
+    # # An alternative way of writing the above.
+    # set.must_be.superset_of [0, 2]
+    # bools.must.channel set
+    class ChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, rhs.to_bool_var_array, 
+          lhs.bind)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set_enum/channel.rb

@@ -2,16 +2,47 @@ module Gecode::Constraints::SetEnum
   class Expression
     # Posts a channel constraint on the variables in the enum with the specified
     # int enum.
-    def channel(enum)
+    def channel(enum, options = {})
       unless enum.respond_to? :to_int_var_array
         raise TypeError, "Expected integer variable enum, for #{enum.class}."
       end
-      
-      # Just provide commutativity to the corresponding int enum constraint.
       if @params[:negate]
-        enum.must_not.channel(@params[:lhs])
-      else
-        enum.must.channel(@params[:lhs])
+        raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The channel constraints does not support the ' +
+          'reification option.'
+      end
+      
+      @params.update(Gecode::Constraints::Set::Util.decode_options(options))
+      @params.update(:rhs => enum)
+      @model.add_constraint Channel::IntChannelConstraint.new(@model, @params)
+    end
+  end
+  
+  # A module that gathers the classes and modules used in channel constraints.
+  module Channel #:nodoc:
+    # Describes a channel constraint which "channels" one enumeration of 
+    # integer variables with one enumeration of set variables. The i:th set 
+    # in the enumeration of set variables is constrainde to includes the value 
+    # of the j:th integer variable. 
+    # 
+    # Neither reification nor negation is supported.
+    # 
+    # == Examples
+    # 
+    #   # +set_enum+ is constrained to channel +int_enum+.
+    #   int_enum.must.channel set_enum
+    # 
+    #   # This is another way of saying the above.
+    #   set_enum.must.channel int_enum
+    #
+    class IntChannelConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, rhs = @params.values_at(:lhs, :rhs)
+        Gecode::Raw::channel(@model.active_space, rhs.to_int_var_array, 
+          lhs.to_set_var_array)
       end
     end
   end

data/lib/gecoder/interface/constraints/set_var_constraints.rb

@@ -75,3 +75,4 @@ require 'gecoder/interface/constraints/set/relation'
 require 'gecoder/interface/constraints/set/cardinality'
 require 'gecoder/interface/constraints/set/connection'
 require 'gecoder/interface/constraints/set/operation'
+require 'gecoder/interface/constraints/set/channel'

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