gecoder 0.2.0 → 0.3.0

data/CHANGES

@@ -0,0 +1,21 @@
+== Version 0.3.0
+
+* The constructor of Gecode::Model no longer has to be called by classes inheriting from it.
+* Added Model#reset! which resets a model after search.
+* Added Model#solution which passes the first solution to a block and returns the result of that block.
+* Added Model#each_soltion which iterates over each solution.
+* Added boolean variables. They are created using Model#bool_var and Model#bool_var_array .
+* Added two options to constraints: propagation strength and reification variable.
+* Linear and simple relation constraints can now also be specified using #equal, #equal_to, #greater, #greater_than,... in addition to comparison operators.
+* Added distinct with offsets.
+* Simple relation constraints can now be used to specify relations between two variables.
+* Added basic boolean domain constraints along with conjunction and disjunction.
+* Added syntactic sugar for combining reifiable constraints with | and &.
+
+== Version 0.2.0
+
+This is the first release of Gecode/R, a Ruby interface to Gecode.
+
+* Added support for finite domain integers.
+* Added some basic relation, linear and distinct constraints.
+* Added the basis needed to model problems and find the first solution.

data/README

@@ -3,6 +3,14 @@
 Gecode/R is a Ruby interface to Gecode, an open, free and efficient environment 
 for developing constraint-based systems and applications.
 
+== Warning
+
+Gecode/R is still in an early development stage, the syntax is by no means 
+final and backwards compatibility will be broken time and time again until 
+later in the development process. Don’t use Gecode/R in production-code yet, 
+it’s merely available this early to allow people to play with it and give 
+feedback.
+
 == Installation
 
 Gecode/R requires Gecode 1.3.1, which can be downloaded from 
@@ -17,4 +25,4 @@ instructions.
 === Building the gem
 
   rake gem
-  gem install pkg/gecoder-0.x.gem
+  gem install pkg/gecoder-0.x.x.gem

data/ext/missing.cpp

@@ -152,7 +152,7 @@ MSpace::MSpace(MSpace& s, bool share) : Gecode::Space(share, s), d(new Private)
 		
 		for(it = s.d->boolArrays.begin(); it != eend; it++)
 		{
-			Gecode::MBoolVarArray *bva = new Gecode::MBoolVarArray;
+			Gecode::MBoolVarArray *bva = new Gecode::MBoolVarArray(this, (*it).second->ptr()->size());
 			
 			bva->ptr()->update(this, share, *(*it).second->ptr() );
 			

data/ext/vararray.cpp

@@ -164,6 +164,10 @@ MBoolVarArray::MBoolVarArray(const Gecode::BoolVarArray &arr) : d(new Private)
 	setSize(arr.size());
 	setCount(0);
 }
+MBoolVarArray::MBoolVarArray (Space *home, int n) : d(new Private)
+{
+	setArray(Gecode::BoolVarArray(home, n));
+}
 
 MBoolVarArray::~MBoolVarArray()
 {

data/ext/vararray.h

@@ -83,7 +83,8 @@ class MBoolVarArray : public MVarArray
 	public:
 		MBoolVarArray();
 		MBoolVarArray(const Gecode::BoolVarArray &arr);
-		
+		MBoolVarArray(Space *home, int n);
+
 		~MBoolVarArray();
 		
 		void enlargeArray(Gecode::Space *parent, int n = 1);

data/lib/gecoder/bindings/bindings.rb

@@ -188,6 +188,11 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 		ns.add_cxx_class "MBoolVarArray" do |klass|
 			klass.bindname = "BoolVarArray"
 			klass.add_constructor
+      klass.add_constructor do |func|
+        func.add_parameter "Gecode::MSpace *", "home"
+        func.add_parameter "int", "n"
+      end
+      
 			klass.add_method "at", "Gecode::BoolVar&" do |method|
 				method.add_parameter "int", "index"
 			end
@@ -195,6 +200,11 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 			klass.add_operator "[]", "Gecode::BoolVar&" do |method|
 				method.add_parameter "int", "index"
 			end
+      
+      klass.add_operator "[]=", "Gecode::BoolVar&" do |method|
+        method.add_parameter "int", "index"
+        method.add_parameter "Gecode::BoolVar", "val"
+      end
 			
 			klass.add_method "size", "int"
 			
@@ -428,6 +438,22 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 			klass.add_constructor do |method|
 				method.add_parameter "Gecode::IntVar", "x"
 			end
+      
+      klass.add_method "max", "int"
+      
+      klass.add_method "min", "int"
+      klass.add_method "med", "int"
+      klass.add_method "val", "int"
+      klass.add_method "size", "unsigned int"
+      klass.add_method "width", "unsigned int"
+      klass.add_method "degree", "unsigned int"
+      
+      klass.add_method "range", "bool"
+      klass.add_method "assigned", "bool"
+      klass.add_method "in", "bool" do |method|
+        method.add_parameter "int", "n"
+      end
+      
 			klass.add_method "update", "void" do |method|
 				method.add_parameter "Gecode::MSpace*", "home"
 				method.add_parameter "bool", "share"
@@ -545,6 +571,12 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 					method.add_parameter "Gecode::IntRelType", "irt"
 					method.add_parameter "Gecode::IntConLevel", "icl"
 				end
+        
+        klass.add_method "post" do |method|
+          method.add_parameter "Gecode::MSpace *", "home"
+          method.add_parameter "Gecode::IntRelType", "irt"
+          method.add_parameter "Gecode::BoolVar", "b"
+        end
 				
 				klass.add_operator "+", "Gecode::MiniModel::LinExpr" do |operator|
 					operator.add_parameter("Gecode::MiniModel::LinExpr", "exp")
@@ -597,17 +629,17 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 				klass.add_constructor do |method|
 					method.add_parameter "Gecode::MiniModel::BoolExpr", "e"
 				end
-				
+        
+				klass.add_constructor do |method|
+          method.add_parameter "Gecode::BoolVar", "e"
+        end
+        
 				klass.add_constructor do |method|
 					method.add_parameter "Gecode::MiniModel::BoolExpr", "l"
 					method.add_parameter "Gecode::MiniModel::BoolExpr::NodeType", "t"
 					method.add_parameter "Gecode::MiniModel::BoolExpr", "r"
 				end
 				
-				klass.add_constructor do |method|
-					method.add_parameter "Gecode::BoolVar", "e"
-				end
-				
 				klass.add_constructor do |method|
 					method.add_parameter "Gecode::MiniModel::BoolExpr", "l"
 					method.add_parameter "Gecode::MiniModel::BoolExpr::NodeType", "t"
@@ -616,6 +648,15 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 				klass.add_constructor do |method|
 					method.add_parameter "Gecode::MiniModel::LinRel", "e"
 				end
+        
+        klass.add_method "post" do |method|
+          method.add_parameter "Gecode::MSpace *", "home"
+        end
+        
+        klass.add_method "post" do |method|
+          method.add_parameter "Gecode::MSpace *", "home"
+          method.add_parameter "bool", "t"
+        end
 			end
 			
 			minimodelns.add_cxx_class "BoolRel" do |klass|
@@ -857,6 +898,15 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
 			func.add_parameter "Gecode::BvarSel", "vars"
 			func.add_parameter "Gecode::BvalSel", "vals"
 		end
+    
+    ns.add_function "branch" do |func|
+      func.add_parameter "Gecode::MSpace *", "home"
+      func.add_parameter "Gecode::MBoolVarArray *", "iva" do |param|
+        param.custom_conversion = "*ruby2Gecode_MBoolVarArrayPtr(argv[1], 2)->ptr()"
+      end
+      func.add_parameter "Gecode::BvarSel", "vars"
+      func.add_parameter "Gecode::BvalSel", "vals"
+    end
 		
 		ns.add_function "branch" do |func|
 			func.add_parameter "Gecode::MSpace *", "home"

data/lib/gecoder/interface.rb

@@ -1,4 +1,5 @@
 require 'gecoder/interface/binding_changes'
+require 'gecoder/interface/variables'
 require 'gecoder/interface/model'
 require 'gecoder/interface/search'
 require 'gecoder/interface/constraints'

data/lib/gecoder/interface/binding_changes.rb

@@ -6,106 +6,208 @@
 #
 # This layer should be moved to the C++ side instead when possible for better
 # performance.
-module Gecode::Raw
-  class Space
-    # Creates the specified number of integer variables in the store. 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)
+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 int_var.
+      def new_bool_vars(count = 1)
+        bool_var_store.new_vars(count)
+      end
+      
+      # Gets the int variable with the specified index, nil if none exists.
+      def bool_var(index)
+        bool_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
     end
     
-    # Gets the int variable with the specified index, nil if none exists.
-    def int_var(index)
-      int_var_store[index]
+    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
     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::Raw::IntVarStore.new(self) 
+    class BoolVar
+      # Aliases to make method-names more ruby-like.
+      alias_method :assigned?, :assigned
+      
+      def true?
+        val == 1
       end
-      return @int_var_store
     end
   end
-
-  # A store in which int variables are created and stored.
-  class IntVarStore
-    # Design note: The store used to double its size when it needed to grow
-    # leaving unallocated slots (in rev 16). This was changed to only growing
-    # the amount of space needed because the additional information about which
-    # slot is the next unallocated one could not be encoded without changes to
-    # the bindings (and without that information we can not deduce the store
-    # from the new copy of space). So for additional performance the bindings 
-    # should grow the array more than needed (when this is moved to the bindings).
-    
-    private
   
-    # A string that identifies the array used by the store.
-    ARRAY_IDENTIFIER = 'int_array'
+  # 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
+    # @next_index, @var_array, @size, ARRAY_IDENTIFIER and #new_storage_array .
+    module VarStoreMethods
+      # Returns the int var with the specified index, nil if none exists.
+      def [](index)
+        if index < 0 or index >= @next_index
+          return nil
+        end
+        return @var_array.at(index)
+      end
+      
+      private
+      
+      # Grows the store to the new size.
+      def grow(new_size)
+        new_array = new_storage_array(new_size)
+        @var_array.size.times do |i|
+          new_array[i] = @var_array[i]
+        end
+        @var_array = new_array
+        @size = new_size
+      end
+    end
   
-    public
+    # A store in which int variables are created and stored.
+    class IntVarStore
+      # Design note: The store used to double its size when it needed to grow
+      # leaving unallocated slots (in rev 16). This was changed to only growing
+      # the amount of space needed because the additional information about which
+      # slot is the next unallocated one could not be encoded without changes to
+      # the bindings (and without that information we can not deduce the store
+      # from the new copy of space). So for additional performance the bindings 
+      # should grow the array more than needed (when this is moved to the bindings).
+      
+      include VarStoreMethods
+      
+      private
     
-    # Creates a store for the specified space with the specified capacit.
-    def initialize(space)
-      @var_array = space.int_var_array(ARRAY_IDENTIFIER)
-      if @var_array.nil?
-        # Create a new one.
-        @var_array = Gecode::Raw::IntVarArray.new(space, 0)
-        space.own(@var_array, ARRAY_IDENTIFIER)
-      end
-
-      @size = @var_array.size
-      @next_index = @size
-      @space = space
-    end
+      # A string that identifies the array used by the store.
+      ARRAY_IDENTIFIER = 'int_array'
     
-    # 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)
-      grow(@next_index + count) # See the design note for more information.
-      count.times do |i|
-        @var_array[@next_index] = Gecode::Raw::IntVar.new(@space, 
-          min, max)
-        @next_index += 1
+      public
+      
+      # Creates a store for the specified space with the specified capacit.
+      def initialize(space)
+        @space = space
+        
+        @var_array = space.int_var_array(ARRAY_IDENTIFIER)
+        if @var_array.nil?
+          # Create a new one.
+          @var_array = new_storage_array(0)
+        end
+  
+        @size = @var_array.size
+        @next_index = @size
       end
       
-      ((@next_index - count)...@next_index).to_a
-    end
-
-    # Returns the int var with the specified index, nil if none exists.
-    def [](index)
-      if index < 0 or index >= @next_index
-        return nil
+      # 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)
+        grow(@next_index + count) # See the design note for more information.
+        count.times do |i|
+          @var_array[@next_index] = Gecode::Raw::IntVar.new(@space, 
+            min, max)
+          @next_index += 1
+        end
+        
+        ((@next_index - count)...@next_index).to_a
+      end
+  
+      # Returns the int var with the specified index, nil if none exists.
+      def [](index)
+        if index < 0 or index >= @next_index
+          return nil
+        end
+        return @var_array.at(index)
+      end
+  
+      private
+      
+      # Creates a new storage array for int variables.
+      def new_storage_array(new_size)
+        arr = Gecode::Raw::IntVarArray.new(@space, new_size)
+        @space.own(arr, ARRAY_IDENTIFIER)
+        return arr
       end
-      return @var_array.at(index)
     end
-
-    private
     
-    # Grows the store to the new size.
-    def grow(new_size)
-      if new_size <= @size
-        raise ArgumentError, 'New size must be larger than the old one.'
+    # A store in which int variables are created and stored.
+    class BoolVarStore
+      # TODO: can we refactor this better seeing as IntVarStore and BoolVarStore
+      # are similar?
+      
+      include VarStoreMethods
+      
+      private
+    
+      # A string that identifies the array used by the store.
+      ARRAY_IDENTIFIER = 'bool_array'
+    
+      public
+      
+      # Creates a store for the specified space with the specified capacit.
+      def initialize(space)
+        @space = space
+      
+        @var_array = space.bool_var_array(ARRAY_IDENTIFIER)
+        if @var_array.nil?
+          # Create a new one.
+          @var_array = new_storage_array(0)
+        end
+  
+        @size = @var_array.size
+        @next_index = @size
       end
       
-      new_array = Gecode::Raw::IntVarArray.new(@space, new_size)
-      @var_array.size.times do |i|
-        new_array[i] = @var_array[i]
+      # Creates the specified number of new bool variables. Returns the indices 
+      # of the created variables as an array.
+      def new_vars(count = 1)
+        grow(@next_index + count) # See the design note for more information.
+        count.times do |i|
+          @var_array[@next_index] = Gecode::Raw::BoolVar.new(@space, 0, 1)
+          @next_index += 1
+        end
+        
+        ((@next_index - count)...@next_index).to_a
       end
-      @space.own(new_array, ARRAY_IDENTIFIER)
-      @var_array = new_array
-      @size = new_size
-    end
-  end
   
-  class IntVar
-    # Aliases to make method-names more ruby-like.
-    alias_method :assigned?, :assigned
-    alias_method :in?, :in
-    alias_method :range?, :range
+      private
+      
+      # Creates a new storage array for bool variables.
+      def new_storage_array(new_size)
+        arr = Gecode::Raw::BoolVarArray.new(@space, new_size)
+        @space.own(arr, ARRAY_IDENTIFIER)
+        return arr
+      end
+    end
   end
 end
-