gecoder 0.8.2 → 0.8.3

data/CHANGES

@@ -1,3 +1,17 @@
+== Version 0.8.3 
+This release adds regular expression constraints, the last channel
+constraint and various minor convenience improvements. It also fixes a
+rather serious bug that occurs when using the latest patchlevels of Ruby
+1.8.6. 
+
+* [#20888] Fixed a GC bug causing problems with Ruby 1.8.6 at patchlevels around 230.
+* Boolean constraints can no longer be specified using the form "bool.must == true". Only the "bool.must_be.true" form can now be used.
+* Added constants in Model that contain the limits of the variables' domains.
+* The domain when construction arrays and matrices of int variables now default to the same as when creating single variables (the largest possible domain).
+* Model#branch_on now accepts single variables as well as enums.
+* Added channel constraints between single set variables and enumerations of boolean variables.
+* Added integer and boolean regular expression constraints. Thanks goes to Eivind Eklund for providing the idea for the syntax used to specify the regular expressions.
+
 == Version 0.8.2
 This release adds search statistics along with some new arithmetic constraints 
 and channel constraints between boolean and integer variables.

data/ext/gecoder.cpp

@@ -0,0 +1,181 @@
+/**
+ * Gecode/R, a Ruby interface to Gecode.
+ * Copyright (C) 2007 The Gecode/R development team.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ **/
+
+#include "gecoder.h"
+#include "gecode.hh"
+
+#include <iostream>
+#include <map>
+
+namespace Gecode {
+  MSpace::MSpace() {
+  }
+
+  MSpace::MSpace(bool share, MSpace& s) : Gecode::Space(share, s) {
+    int_variables.update(this, share, s.int_variables);
+    bool_variables.update(this, share, s.bool_variables);
+    set_variables.update(this, share, s.set_variables);
+  }
+
+  MSpace::~MSpace() {
+#ifdef DEBUG
+    fprintf(stderr, "gecoder: destructing MSpace %p\n", this);
+#endif
+  }
+
+  Gecode::Space* MSpace::copy(bool share) {
+    return new MSpace(share, *this);
+  }
+
+  /*
+   * Creates a new integer variable with the specified domain and 
+   * returns its identifier.
+   */
+  int MSpace::new_int_var(int min, int max) {
+    int id = int_variables.size();
+    Gecode::IntVar* var = new IntVar(this, min, max);
+    int_variables.add(this, *var);
+    return id;
+  }
+  int MSpace::new_int_var(IntSet domain) {
+    int id = int_variables.size();
+    Gecode::IntVar* var = new IntVar(this, domain);
+    int_variables.add(this, *var);
+    return id;
+  }
+
+  /*
+   * Creates a new boolean variable and returns its identifier.
+   */
+  int MSpace::new_bool_var() {
+    int id = bool_variables.size();
+    Gecode::BoolVar* var = new BoolVar(this, 0, 1);
+    bool_variables.add(this, *var);
+    return id;
+  }
+
+  /*
+   * Creates a new set variable with the specified domain and returns 
+   * its identifier.
+   */
+  int MSpace::new_set_var(const IntSet& glb, const IntSet& lub, unsigned int card_min, unsigned int card_max) {
+    int id = set_variables.size();
+    Gecode::SetVar* var = new SetVar(this, glb, lub, card_min, card_max);
+    set_variables.add(this, *var);
+    return id;
+  }
+
+  /*
+   * Fetches the integer variable with the specified identifier.
+   */
+  Gecode::IntVar* MSpace::int_var(int id) {
+    return &int_variables[id];
+  }
+
+  /*
+   * Fetches the integer variable with the specified identifier.
+   */
+  Gecode::BoolVar* MSpace::bool_var(int id) {
+    return &bool_variables[id];
+  }
+
+  /*
+   * Fetches the integer variable with the specified identifier.
+   */
+  Gecode::SetVar* MSpace::set_var(int id) {
+    return &set_variables[id];
+  }
+
+  void MSpace::gc_mark() {
+    for(int i = 0; i < int_variables.size(); i++) {
+      rb_gc_mark(Rust_gecode::cxx2ruby(&int_variables[i], false, false));
+    }
+    for(int i = 0; i < bool_variables.size(); i++) {
+      rb_gc_mark(Rust_gecode::cxx2ruby(&bool_variables[i], false, false));
+    }
+    for(int i = 0; i < set_variables.size(); i++) {
+      rb_gc_mark(Rust_gecode::cxx2ruby(&set_variables[i], false, false));
+    }
+  }
+
+  // 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, false)); 
+  }
+
+  /* 
+   * MDFS is the same as DFS but with the size of a space inferred from the
+   * other arguments, since it can't be done from the Ruby side.
+   */
+  MDFS::MDFS(MSpace* space, unsigned int c_d, unsigned int a_d, Search::Stop* st) : Gecode::Search::DFS(space, c_d, a_d, st, sizeof(space)) {
+  }
+
+  MDFS::~MDFS() {
+  }
+
+  /* 
+   * MBAB is the same as BAB but with the size of a space inferred from the
+   * other arguments, since it can't be done from the Ruby side.
+   */
+  MBAB::MBAB(MSpace* space, const Search::Options &o) : Gecode::BAB<MSpace>(space, o) {
+  }
+
+  MBAB::~MBAB() {
+  }
+
+  namespace Search {
+    /* 
+     * MStop combines the time stop and fail stop, but for what reason?
+     * TODO: Try removing MStop, replacing it with plain Stop objects.
+     */
+
+    struct MStop::Private {
+      Gecode::Search::TimeStop* ts;
+      Gecode::Search::FailStop* fs;
+    };
+
+    MStop::MStop() : d(new Private) {
+      d->ts = 0;
+      d->fs = 0;
+    }
+
+    MStop::MStop(int fails, int time) : d(new Private) {
+      d->ts = new Search::TimeStop(time);
+      d->fs = new Search::FailStop(fails);
+    }
+
+    MStop::~MStop() {
+    }
+
+    bool MStop::stop(const Gecode::Search::Statistics &s) {
+      if (!d->fs && !d->ts) return false;
+      return d->fs->stop(s) || d->ts->stop(s);
+    }
+
+    Gecode::Search::Stop* MStop::create(int fails, int time) {
+      if (fails < 0 && time < 0) return 0;
+      if (fails < 0) return new Search::TimeStop(time);
+      if (time  < 0) return new Search::FailStop(fails);
+
+      return new MStop(fails, time);
+    }
+  }
+}

data/ext/gecoder.h

@@ -0,0 +1,94 @@
+/**
+ * Gecode/R, a Ruby interface to Gecode.
+ * Copyright (C) 2007 The Gecode/R development team.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ **/
+
+#ifndef __GECODER_H
+#define __GECODER_H
+
+#include <ruby.h>
+
+#include <gecode/kernel.hh>
+#include <gecode/int.hh>
+#include <gecode/search.hh>
+#include <gecode/minimodel.hh>
+#include <gecode/set.hh>
+
+#include "vararray.h"
+
+namespace Gecode {
+  class MSpace : public Space {
+    public:
+      MSpace();
+      MSpace(bool share, MSpace& s);
+      ~MSpace();
+      Gecode::Space *copy(bool share);
+
+      int new_int_var(int min, int max);
+      int new_int_var(IntSet domain);
+      Gecode::IntVar* int_var(int id);
+
+      int new_bool_var();
+      Gecode::BoolVar* bool_var(int id);
+
+      int new_set_var(const IntSet& glb, const IntSet& lub, unsigned int card_min, unsigned int card_max);
+      Gecode::SetVar* set_var(int id);
+
+      void gc_mark();
+
+      void constrain(MSpace* s);
+
+    private:
+      Gecode::IntVarArray int_variables;
+      Gecode::BoolVarArray bool_variables;
+      Gecode::SetVarArray set_variables;
+  };
+  
+  class MDFS : public Gecode::Search::DFS {
+    public:
+      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, const Search::Options &o);
+      ~MBAB();
+  };
+
+  namespace Search {
+    class MStop : public Gecode::Search::Stop {
+      private:
+        MStop(int fails, int time);
+
+      public:
+        MStop();
+        ~MStop();
+
+        bool stop (const Gecode::Search::Statistics &s);
+        static Gecode::Search::Stop* create(int fails, int time);
+
+      private:
+        struct Private;
+        Private *const d;
+    };
+  }
+}
+
+#endif
+
+

data/ext/vararray.cpp

@@ -133,7 +133,7 @@ IntVar &MIntVarArray::operator [](int index)
 void MIntVarArray::gc_mark()
 {
   for(int i = size(); i--; ) {
-		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i]), false, false));
 	}
 }
 
@@ -210,7 +210,7 @@ Gecode::BoolVar &MBoolVarArray::operator[](int index)
 void MBoolVarArray::gc_mark()
 {
   for(int i = size(); i--; ) {
-		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i]), false, false));
 	}
 }
 
@@ -306,7 +306,7 @@ Gecode::SetVar &MSetVarArray::operator[](int index)
 void MSetVarArray::gc_mark()
 {
   for(int i = size(); i--; ) {
-		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i])));
+		rb_gc_mark(Rust_gecode::cxx2ruby(&(d->array[i]), false, false));
 	}
 }
 

data/lib/gecoder/bindings/bindings.rb

@@ -77,7 +77,7 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
   b.include_header 'gecode/set.hh', Rust::Bindings::HeaderGlobal
   b.include_header 'gecode/search.hh', Rust::Bindings::HeaderGlobal
   b.include_header 'gecode/minimodel.hh', Rust::Bindings::HeaderGlobal
-  b.include_header 'missing.h', Rust::Bindings::HeaderLocal
+  b.include_header 'gecoder.h', Rust::Bindings::HeaderLocal
   
   b.add_custom_definition ruby2intargs
   b.add_custom_definition custom_mark_definitions
@@ -351,52 +351,47 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       klass.add_method "tuples", "int"
     end
     
-    ns.add_cxx_class "MBranchingDesc" do |klass|
-      klass.bindname = "BranchingDesc"
-      klass.add_constructor
-      klass.add_method "alternatives", "int"
-      klass.add_method "size", "int"
-    end
-    
     ns.add_cxx_class "MSpace" do |klass|
       klass.bindname = "Space"
       klass.function_mark = 'Gecode_MSpace_custom_mark'
       
       klass.add_constructor
-      
-      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"
+      klass.add_method "new_int_var", "int" do |method|
+        method.add_parameter "int", "min"
+        method.add_parameter "int", "max"
       end
       
-      klass.add_method "own" do |method|
-        method.add_parameter "Gecode::MBoolVarArray *", "x"
-        method.add_parameter "char*", "name"
+      klass.add_method "new_int_var", "int" do |method|
+        method.add_parameter "Gecode::IntSet", "domain"
       end
-      
-      klass.add_method "own" do |method|
-        method.add_parameter "Gecode::MSetVarArray *", "x"
-        method.add_parameter "char*", "name"
+
+      klass.add_method "new_bool_var", "int" do |method|
       end
-      
-      klass.add_method "intVarArray", "Gecode::MIntVarArray *" do |method|
-        method.add_parameter "char *", "name"
+
+      klass.add_method "new_set_var", "int" do |method|
+        method.add_parameter "Gecode::IntSet", "glb"
+        method.add_parameter "Gecode::IntSet", "lub"
+        method.add_parameter "int", "cardMin"
+        method.add_parameter "int", "cardMax"
       end
-      
-      klass.add_method "boolVarArray", "Gecode::MBoolVarArray *" do |method|
-        method.add_parameter "char *", "name"
+
+      klass.add_method "int_var", "Gecode::IntVar*" do |method|
+        method.add_parameter "int", "id"
       end
-      
-      klass.add_method "setVarArray", "Gecode::MSetVarArray *" do |method|
-        method.add_parameter "char *", "name"
+
+      klass.add_method "bool_var", "Gecode::BoolVar*" do |method|
+        method.add_parameter "int", "id"
       end
       
+      klass.add_method "set_var", "Gecode::SetVar*" do |method|
+        method.add_parameter "int", "id"
+      end
+
       klass.add_method "clone", "Gecode::MSpace *" do |method|
         method.add_parameter "bool", "shared"
       end
@@ -411,13 +406,6 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       # description method used by rspec, and isn't used directly in the 
       # interface.
       #klass.add_method "mdescription", "Gecode::MBranchingDesc *", "description"
-      
-      klass.add_method "commit" do |method|
-        method.add_parameter "Gecode::MBranchingDesc", "desc" do |param|
-          param.custom_conversion = "ruby2Gecode_MBranchingDescPtr(desc, 1)->ptr()"
-        end
-        method.add_parameter "int", "a"
-      end
     end
     
     # The namespace structure doesn't completely mimic Gecode's namespace 
@@ -659,6 +647,57 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       klass.add_method "next", "Gecode::MSpace *"
       klass.add_method "statistics", "Gecode::Search::Statistics"
     end
+
+    ns.add_cxx_class "DFA" do |klass|
+      klass.add_constructor
+    end
+
+    ns.add_cxx_class "REG" do |klass|
+      klass.add_constructor
+
+      klass.add_constructor do |method|
+        method.add_parameter "int", "s"
+      end
+
+      klass.add_constructor do |method|
+        method.add_parameter "Gecode::IntArgs&", "x"
+      end
+
+      klass.add_constructor do |method|
+        method.add_parameter "Gecode::REG&", "r"
+      end
+
+      klass.add_operator "+", "Gecode::REG" do |operator|
+        operator.add_parameter "Gecode::REG&", "r"
+      end
+
+      klass.add_operator "+=", "Gecode::REG&" do |operator|
+        operator.add_parameter "Gecode::REG&", "r"
+      end
+
+      klass.add_operator "|", "Gecode::REG" do |operator|
+        operator.add_parameter "Gecode::REG&", "r"
+      end
+      
+      klass.add_operator "|=", "Gecode::REG&" do |operator|
+        operator.add_parameter "Gecode::REG&", "r"
+      end
+      
+      klass.add_operator "*", "Gecode::REG" do |operator|
+      end
+      
+      klass.add_operator "+", "Gecode::REG" do |operator|
+      end
+
+      klass.add_operator "()", "Gecode::REG" do |operator|
+        operator.add_parameter "int", "n"
+        operator.add_parameter "int", "m"
+      end
+
+      klass.add_operator "()", "Gecode::REG" do |operator|
+        operator.add_parameter "int", "n"
+      end
+    end
     
     # SEARCH NAMESPACE
     
@@ -789,7 +828,7 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
           method.add_parameter "Gecode::MiniModel::LinRel<Gecode::BoolVar>", "e"
         end        
         
-        klass.add_method "post" do |method|
+        klass.add_method "post", "Gecode::BoolVar" do |method|
           method.add_parameter "Gecode::MSpace *", "home"
           method.add_parameter "Gecode::IntConLevel", "icl"
           method.add_parameter "Gecode::PropKind", "pk"
@@ -1276,14 +1315,25 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       func.add_parameter "Gecode::PropKind", "pk"
     end
   
-# 		ns.add_function "regular", "void" do |func|
-# 			func.add_parameter "Gecode::MSpace*", "home"
-# 			func.add_parameter "Gecode::MIntVarArray *", "x" do |param|
-# 				param.custom_conversion = "*ruby2Gecode_MIntVarArrayPtr(argv[1], 2)->ptr()"
-# 			end
-# 			func.add_parameter "Gecode::DFA", "dfa" # TODO: add class DFA
-# 			func.add_parameter "Gecode::IntConLevel", "icl", true
-# 		end
+    ns.add_function "extensional", "void" do |func|
+      func.add_parameter "Gecode::MSpace*", "home"
+      func.add_parameter "Gecode::MIntVarArray *", "x" do |param|
+        param.custom_conversion = "*ruby2Gecode_MIntVarArrayPtr(argv[1], 2)->ptr()"
+      end
+      func.add_parameter "Gecode::REG", "dfa" 
+      func.add_parameter "Gecode::IntConLevel", "icl"
+      func.add_parameter "Gecode::PropKind", "pk"
+    end
+
+    ns.add_function "extensional", "void" do |func|
+      func.add_parameter "Gecode::MSpace*", "home"
+      func.add_parameter "Gecode::MBoolVarArray *", "x" do |param|
+        param.custom_conversion = "*ruby2Gecode_MBoolVarArrayPtr(argv[1], 2)->ptr()"
+      end
+      func.add_parameter "Gecode::REG", "dfa" 
+      func.add_parameter "Gecode::IntConLevel", "icl"
+      func.add_parameter "Gecode::PropKind", "pk"
+    end
     
     ns.add_function "bab", "Gecode::MSpace*" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
@@ -1765,6 +1815,14 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
         param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(argv[2], 3)->ptr()"
       end
     end
+
+    ns.add_function "channel" do |func|
+      func.add_parameter "Gecode::MSpace*", "home"
+      func.add_parameter "Gecode::MBoolVarArray", "x" do |param|
+        param.custom_conversion = "*ruby2Gecode_MBoolVarArrayPtr(argv[1], 2)->ptr()"
+      end
+      func.add_parameter "Gecode::SetVar", "y"
+    end
     
     ns.add_function "weights" do |func|
       func.add_parameter "Gecode::MSpace*", "home"