gecoder 0.5.0 → 0.6.0

data/CHANGES

@@ -1,3 +1,17 @@
+== Version 0.6.0
+This release adds most of the remaining set constraints. It also makes 
+backward-compatibility breaking changes to the way that properties of variables
+are accessed.
+
+* Added channel constraints involving set variables.
+* Added set min and max constraints.
+* Added set sum constraints (optionally weighted or substituted).
+* Added include (match) constraint for sets.
+* Added distinct constraints (distinct and at most one) for sets.
+* Added branch and bound search (optimization search). It's quite shaky at the moment though.
+* Assigned values of variables are now always accessed using #value instread of the various previous methods. The methods for extracting information from set variables have been changed and renamed.
+* Enumerations containing variables now provide a convenience method #values which returns an array of the enum's values.
+
 == Version 0.5.0
 This release adds set variables and some of their constraints, along with the 
 last of the boolean constraints.
@@ -10,10 +24,9 @@ last of the boolean constraints.
 * Added set cardinality constraints.
 
 == Version 0.4.0
-This release adds most of the constraints supported by Gecode for integer
-variables.
+This release adds most of the integer variable constraints supported by Gecode.
 
-* [#11861] Fixed a bug stopping the creating of int variables with non-range domains.
+* [#11861] Fixed a bug stopping the creation of int variables with non-range domains.
 * Added domain constraints for int variables.
 * Added equality constraint for int enums.
 * Matrices of integer and boolean variables can now be created using Model#int_var_matrix Model#bool_var_matrix.

data/example/magic_sequence.rb

@@ -29,7 +29,7 @@ class MagicSequence < Gecode::Model
   end
   
   def to_s
-    @sequence.map{ |element| element.val }.join(', ')
+    @sequence.values.join(', ')
   end
 end
 

data/example/queens.rb

@@ -25,7 +25,7 @@ class NQueens < Gecode::Model
   
   # Displays the assignment as a chessboard with queens denoted by 'x'.
   def to_s
-    rows = @queen_rows.map{ |var| var.val }
+    rows = @queen_rows.values
   
     separator = '+' << '-' * (3 * @size + (@size - 1)) << "+\n"
     res = (0...@size).inject(separator) do |s, i|

data/example/send_more_money.rb

@@ -25,7 +25,7 @@ class SendMoreMoney < Gecode::Model
 
   def to_s
     %w{s e n d m o r y}.zip(@letters).map do |text, letter|
-      "#{text}: #{letter.val}" 
+      "#{text}: #{letter.value}" 
     end.join(', ')
   end
 

data/example/sudoku.rb

@@ -44,7 +44,7 @@ class Sudoku < Gecode::Model
     separator = '+' << '-' * (3 * @size + (@size - 1)) << "+\n"
     res = (0...@size).inject(separator) do |s, i|
       (0...@size).inject(s + '|') do |s, j|
-        s << " #{@squares[i,j].val} |"
+        s << " #{@squares[i,j].value} |"
       end << "\n" << separator
     end
   end

data/ext/missing.cpp

@@ -18,6 +18,7 @@
 **/
 
 #include "missing.h"
+#include "gecode.hh"
 
 #include <iostream>
 #include <map>
@@ -193,6 +194,14 @@ void MSpace::own(Gecode::MSetVarArray *sva, const char *name)
 	d->setArrays[name] = sva;
 }
 
+// For BAB.
+void MSpace::constrain(MSpace* s)
+{
+  // Call Ruby's constrain.
+  rb_funcall(Rust_gecode::cxx2ruby(this), rb_intern("constrain"), 1,
+    Rust_gecode::cxx2ruby(s)); 
+}
+
 Gecode::MIntVarArray *MSpace::intVarArray(const char *name) const
 {
 	if ( d->intArrays.find(name) == d->intArrays.end() ) return 0;
@@ -211,7 +220,6 @@ Gecode::MSetVarArray *MSpace::setVarArray(const char *name ) const
 	return d->setArrays[name];
 }
 
-
 Gecode::MBranchingDesc *MSpace::mdescription()
 {
 	if(!this->failed() || !d->description->ptr() )
@@ -237,6 +245,15 @@ MDFS::~MDFS()
 }
 
 
+// BAB
+MBAB::MBAB(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st) : Gecode::BAB<MSpace>(space, c_d, a_d, st)
+{
+}
+
+MBAB::~MBAB()
+{
+}
+
 namespace Search {
 
 // Stop
@@ -284,6 +301,3 @@ Gecode::Search::Stop* MStop::create(int fails, int time)
 }
 
 }
-
-
-

data/ext/missing.h

@@ -61,6 +61,8 @@ class MSpace : public Space
 		void own(Gecode::MBoolVarArray *bva, const char *name);
 		void own(Gecode::MSetVarArray *sva, const char *name);
 		
+		void constrain(MSpace* s);
+		
 		Gecode::MIntVarArray *intVarArray(const char *name ) const;
 		Gecode::MBoolVarArray *boolVarArray(const char *name ) const;
 		Gecode::MSetVarArray *setVarArray(const char *name) const;
@@ -80,6 +82,12 @@ class MDFS : public Gecode::Search::DFS
 		MDFS(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st = 0);
 		~MDFS();
 };
+class MBAB : public Gecode::BAB<MSpace>
+{
+	public:
+		MBAB(MSpace* space, unsigned int c_d, unsigned int a_d, Search::Stop* st = 0);
+		~MBAB();
+};
 
 namespace Search {
 class MStop : public Gecode::Search::Stop

data/lib/gecoder/bindings.rb

@@ -1,7 +1,34 @@
 require 'gecode.so'
 module Gecode
-  # The bindings are located in ::GecodeRaw, so we assign that to ::Gecode::Raw.
-  # This is done because bindings/bindings.rb use ::GecodeRaw and appears to
-  # have limitations that do not allow using a sub-namespace.
+  # The Gecode::Raw module is what the interface should use to access methods
+  # in Gecode. The actual bindings are located in ::GecodeRaw.
+  
+  # We just make Gecode::Raw an alias of the real module.
   Raw = ::GecodeRaw
+  # Log all calls via Gecode::Raw.
+  #Raw = ::LoggingLayer
+  
+  # Describes a layer that delegates to GecodeRaw only after having logged the 
+  # call.
+  module LoggingLayer
+    require 'logger'
+  
+    def self.method_missing(name, *args)
+      logger.info{ "#{name}(#{args.join(', ')})" }
+      ::GecodeRaw.send(name, *args)
+    end
+    
+    def self.const_missing(name)
+      ::GecodeRaw.const_get(name)
+    end
+    
+    # Gets the logger, or creates one if none exists.
+    def self.logger
+      return @logger unless @logger.nil?
+      file = open('gecoder.log', File::WRONLY | File::APPEND | File::CREAT)
+      @logger = ::Logger.new(file)
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+      @logger
+    end
+  end
 end

data/lib/gecoder/bindings/bindings.rb

@@ -293,6 +293,10 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       
       klass.add_method "debug"
       
+      klass.add_method "constrain" do |method|
+        method.add_parameter "Gecode::MSpace*", "s"
+      end
+      
       klass.add_method "own" do |method|
         method.add_parameter "Gecode::MIntVarArray *", "x"
         method.add_parameter "char*", "name"
@@ -390,6 +394,11 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
         method.add_parameter "int", "max"
       end
       
+      klass.add_constructor do |method|
+        method.add_parameter "Gecode::MSpace*", "home"
+        method.add_parameter "Gecode::IntSet", "s"
+      end
+      
       klass.add_method "max", "int"
       
       klass.add_method "min", "int"
@@ -547,6 +556,19 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       klass.add_method "statistics", "Gecode::Search::Statistics"
     end
     
+    ns.add_cxx_class "MBAB" do |klass|
+      klass.bindname = "BAB"
+      klass.add_constructor do |method|
+        method.add_parameter "Gecode::MSpace *", "s"
+        method.add_parameter "int", "c_d"
+        method.add_parameter "int", "a_d"
+        method.add_parameter "Gecode::Search::MStop *", "st"
+      end
+      
+      klass.add_method "next", "Gecode::MSpace *"
+      klass.add_method "statistics", "Gecode::Search::Statistics"
+    end
+    
     # SEARCH NAMESPACE
     
     ns.add_namespace "Search" do |searchns|

data/lib/gecoder/interface/binding_changes.rb

@@ -6,120 +6,83 @@
 #
 # This layer should be moved to the C++ side instead when possible for better
 # performance.
-module Gecode
-  module Raw
-    class Space
-      # Creates the specified number of integer variables in the space. Returns
-      # the indices with which they can then be accessed using int_var.
-      def new_int_vars(min, max, count = 1)
-        int_var_store.new_vars(min, max, count)
-      end
-      
-      # Gets the int variable with the specified index, nil if none exists.
-      def int_var(index)
-        int_var_store[index]
-      end
-      
-      # Creates the specified number of boolean variables in the space. Returns
-      # the indices with which they can then be accessed using bool_var.
-      def new_bool_vars(count = 1)
-        bool_var_store.new_vars(count)
-      end
-      
-      # Gets the bool variable with the specified index, nil if none exists.
-      def bool_var(index)
-        bool_var_store[index]
-      end
-      
-      # Creates the specified number of set variables in the space with the 
-      # specified domain for greatest lower bound and least upper bound 
-      # (specified as either a range or enum). 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. Returns 
-      # the indices with which they can then be accessed using set_var.
-      def new_set_vars(*vars)
-        set_var_store.new_vars(*vars)
-      end
-      
-      # Gets the set variable with the specified index, nil if none exists.
-      def set_var(index)
-        set_var_store[index]
-      end
-      
-      private
-      
-      # Retrieves the store used for integer variables. Creates one if none
-      # exists.
-      def int_var_store
-        if @int_var_store.nil?
-          @int_var_store = Gecode::Util::IntVarStore.new(self) 
-        end
-        return @int_var_store
-      end
-      
-      # Retrieves the store used for boolean variables. Creates one if none
-      # exists.
-      def bool_var_store
-        if @bool_var_store.nil?
-          @bool_var_store = Gecode::Util::BoolVarStore.new(self) 
-        end
-        return @bool_var_store
-      end
-      
-      # Retrieves the store used for set variables. Creates one if none exists.
-      def set_var_store
-        if @set_var_store.nil?
-          @set_var_store = Gecode::Util::SetVarStore.new(self) 
-        end
-        return @set_var_store
-      end
+module GecodeRaw
+  class Space
+    # Creates the specified number of integer variables in the space with the
+    # specified domain. Returns the indices with which they can then be 
+    # accessed using int_var. The domain can be given as a Range (trated 
+    # specially) or as another enum.
+    def new_int_vars(domain, count = 1)
+      int_var_store.new_vars(domain, count)
     end
     
-    class IntVar
-      # Aliases to make method-names more ruby-like.
-      alias_method :assigned?, :assigned
-      alias_method :in?, :in
-      alias_method :include?, :in
-      alias_method :range?, :range
+    # Gets the int variable with the specified index, nil if none exists.
+    def int_var(index)
+      int_var_store[index]
     end
     
-    class BoolVar
-      # Aliases to make method-names more ruby-like.
-      alias_method :assigned?, :assigned
-      
-      def true?
-        val == 1
+    # Creates the specified number of boolean variables in the space. Returns
+    # the indices with which they can then be accessed using bool_var.
+    def new_bool_vars(count = 1)
+      bool_var_store.new_vars(count)
+    end
+    
+    # Gets the bool variable with the specified index, nil if none exists.
+    def bool_var(index)
+      bool_var_store[index]
+    end
+    
+    # Creates the specified number of set variables in the space with the 
+    # specified domain for greatest lower bound and least upper bound 
+    # (specified as either a range or enum). 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. Returns 
+    # the indices with which they can then be accessed using set_var.
+    def new_set_vars(*vars)
+      set_var_store.new_vars(*vars)
+    end
+    
+    # Gets the set variable with the specified index, nil if none exists.
+    def set_var(index)
+      set_var_store[index]
+    end
+    
+    # Used by Gecode during BAB-search.
+    def constrain(best_so_far_space)
+      Gecode::Model.constrain(self, best_so_far_space)
+    end
+    
+    private
+    
+    # Retrieves the store used for integer variables. Creates one if none
+    # exists.
+    def int_var_store
+      if @int_var_store.nil?
+        @int_var_store = Gecode::Util::IntVarStore.new(self) 
       end
-      
-      def false?
-        val == 0
+      return @int_var_store
+    end
+    
+    # Retrieves the store used for boolean variables. Creates one if none
+    # exists.
+    def bool_var_store
+      if @bool_var_store.nil?
+        @bool_var_store = Gecode::Util::BoolVarStore.new(self) 
       end
+      return @bool_var_store
     end
     
-    class SetVar
-      # Aliases to make method-names more ruby-like.
-      alias_method :assigned?, :assigned
-      
-      alias_method :include_glb?, :contains
-      alias_method :include?, :contains
-      def include_lub?(element)
-        !notContains(element)
+    # Retrieves the store used for set variables. Creates one if none exists.
+    def set_var_store
+      if @set_var_store.nil?
+        @set_var_store = Gecode::Util::SetVarStore.new(self) 
       end
-      
-      alias_method :glb_min, :glbMin
-      alias_method :glb_max, :glbMax
-      alias_method :lub_min, :lubMin
-      alias_method :lub_max, :lubMax
-      
-      alias_method :glb_size, :glbSize
-      alias_method :val_size, :glbSize
-      alias_method :lub_size, :lubSize
-      
-      alias_method :card_min, :cardMin
-      alias_method :card_max, :cardMax
+      return @set_var_store
     end
   end
-  
+end
+
+module Gecode
   # Various utility (mainly used to change the behavior of the raw bindings).
   module Util
     # Provides common methods to the variable stores. The stores must provide
@@ -179,13 +142,24 @@ module Gecode
         @next_index = @size
       end
       
-      # Creates the specified number of new int variables with the specified
-      # range as domain. Returns the indices of the created variables as an array.
-      def new_vars(min, max, count = 1)
+      # Creates the specified number of integer variables in the space with the
+      # specified domain. Returns the indices with which they can then be 
+      # accessed using int_var. The domain can be given as a Range (trated 
+      # specially) or as another enum.
+      def new_vars(domain, count = 1)
         grow(@next_index + count) # See the design note for more information.
         count.times do |i|
+          if domain.kind_of? Range
+            domain_params = [domain.first, domain.last] 
+          elsif domain.kind_of? Enumerable
+            arr = domain.to_a
+            domain_params = [Gecode::Raw::IntSet.new(arr, arr.size)]
+          else
+            raise TypeError, "Expected Enumerable, got #{domain.class}."
+          end
+
           @var_array[@next_index] = Gecode::Raw::IntVar.new(@space, 
-            min, max)
+            *domain_params)
           @next_index += 1
         end
         

data/lib/gecoder/interface/branch.rb

@@ -2,9 +2,9 @@ module Gecode
   class Model
     private
     
-    # Maps the names of the supported variable branch strategies to the 
-    # corresponding constant in Gecode. 
-    BRANCH_VAR_CONSTANTS = {
+    # Maps the names of the supported variable branch strategies for integer and
+    # booleans to the corresponding constant in Gecode. 
+    BRANCH_INT_VAR_CONSTANTS = {
       :none                 => Gecode::Raw::BVAR_NONE,
       :smallest_min         => Gecode::Raw::BVAR_MIN_MIN,
       :largest_min          => Gecode::Raw::BVAR_MIN_MAX, 
@@ -19,16 +19,31 @@ module Gecode
       :smallest_max_regret  => Gecode::Raw::BVAR_REGRET_MAX_MIN, 
       :largest_max_regret   => Gecode::Raw::BVAR_REGRET_MAX_MAX
     }
+    # Maps the names of the supported variable branch strategies for sets to 
+    # the corresponding constant in Gecode. 
+    BRANCH_SET_VAR_CONSTANTS = {
+      :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
+    }
     
-    # Maps the names of the supported value branch strategies to the 
-    # corresponding constant in Gecode. 
-    BRANCH_VALUE_CONSTANTS = {
+    # Maps the names of the supported value branch strategies for integers and
+    # booleans to the corresponding constant in Gecode. 
+    BRANCH_INT_VALUE_CONSTANTS = {
       :min        => Gecode::Raw::BVAL_MIN,
       :med        => Gecode::Raw::BVAL_MED,
       :max        => Gecode::Raw::BVAL_MAX,
       :split_min  => Gecode::Raw::BVAL_SPLIT_MIN,
       :split_max  => Gecode::Raw::BVAL_SPLIT_MAX
     }
+    # Maps the names of the supported value branch strategies for sets to the 
+    # corresponding constant in Gecode. 
+    BRANCH_SET_VALUE_CONSTANTS = {
+      :min  => Gecode::Raw::SETBVAL_MIN,
+      :max  => Gecode::Raw::SETBVAL_MAX
+    }
     
     public
   
@@ -38,7 +53,8 @@ module Gecode
     # used with the :value option. If nothing is specified then :variable uses
     # :none and value uses :min.
     #
-    # The following values can be used with :variable
+    # The following values can be used with :variable for integer and boolean 
+    # enums:
     # [:none]                 The first unassigned variable.
     # [:smallest_min]         The one with the smallest minimum.
     # [:largest_min]          The one with the largest minimum.
@@ -71,32 +87,67 @@ module Gecode
     #                         the largest and second-largest value still in 
     #                         the domain.
     #
-    # The following values can be used with :value
+    # The following values can be used with :value for integer and boolean 
+    # enums:
     # [:min]        Selects the smallest value.
     # [:med]        Select the median value.
     # [:max]        Selects the largest vale
     # [:split_min]  Selects the lower half of the domain.
     # [:split_max]  Selects the upper half of the domain.
+    #
+    # The following values can be used with :variable for set enums:
+    # [:none]                 The first unassigned set.
+    # [:smallest_cardinality] The one with the smallest cardinality.
+    # [:largest_cardinality]  The one with the largest cardinality.
+    # [:smallest_unknown]     The one with the smallest number of unknown 
+    #                         elements 
+    # [:largest_unknown]      The one with the largest number of unknown 
+    #                         elements
+    #
+    # The following values can be used with :value set enums: 
+    # enums:
+    # [:min]        Selects the smallest value in the unknown part of the set.
+    # [:max]        Selects the largest value in the unknown part of the set.
     def branch_on(variables, options = {})
+      if variables.respond_to? :to_int_var_array or 
+          variables.respond_to? :to_bool_var_array
+        add_branch(variables, options, BRANCH_INT_VAR_CONSTANTS, 
+          BRANCH_INT_VALUE_CONSTANTS)
+      elsif variables.respond_to? :to_set_var_array
+        add_branch(variables, options, BRANCH_SET_VAR_CONSTANTS, 
+          BRANCH_SET_VALUE_CONSTANTS)
+      else
+        raise TypeError, "Unknown type of variable enum #{variables.class}."
+      end
+    end
+    
+    private
+    
+    # Adds a branching selection for the specified variable with the specified
+    # options. The hashes are used to decode the options into Gecode's 
+    # constants.
+    def add_branch(variables, options, branch_var_hash, branch_value_hash)
       # Extract optional arguments.
       var_strat = options.delete(:variable) || :none
       val_strat = options.delete(:value) || :min
-
+    
       # Check that the options are correct.
       unless options.empty?
         raise ArgumentError, 'Unknown branching option given: ' + 
           options.keys.join(', ')
       end
-      unless BRANCH_VAR_CONSTANTS.include? var_strat
+      unless branch_var_hash.include? var_strat
         raise ArgumentError, "Unknown variable selection strategy: #{var_strat}"
       end
-      unless BRANCH_VALUE_CONSTANTS.include? val_strat
+      unless branch_value_hash.include? val_strat
         raise ArgumentError, "Unknown value selection strategy: #{val_strat}"
       end
 
-      # Add the branching.
-      Gecode::Raw.branch(active_space, variables.to_var_array, 
-        BRANCH_VAR_CONSTANTS[var_strat], BRANCH_VALUE_CONSTANTS[val_strat])
+      # Add the branching as a gecode interaction.
+      add_interaction do
+        Gecode::Raw.branch(active_space, variables.to_var_array, 
+          branch_var_hash[var_strat], branch_value_hash[val_strat])
+      end
     end
   end
 end