gecoder-with-gecode 1.0.0 → 1.1.0

data/ext/gecode-2.2.0/gecode/int/count.hh

@@ -291,7 +291,7 @@ namespace Gecode { namespace Int { namespace Count {
     /// Number of views which are equal and have been eliminated
     int   c;
     /// Constructor for cloning \a p
-    BaseView(Space* home, bool shr, BaseView& p);
+    BaseView(Space* home, bool shar, BaseView& p);
     /// Constructor for creation
     BaseView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
     /// Specification for this propagator
@@ -334,12 +334,12 @@ namespace Gecode { namespace Int { namespace Count {
     using BaseView<VX,VY,VZ,shr>::atmost;
 
     /// Constructor for cloning \a p
-    EqView(Space* home, bool shr, EqView& p);
+    EqView(Space* home, bool shar, EqView& p);
   public:
     /// Constructor for creation
     EqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
     /// Create copy during cloning
-    virtual Actor* copy(Space* home, bool shr);
+    virtual Actor* copy(Space* home, bool shar);
     /// Perform propagation
     virtual ExecStatus propagate(Space* home, ModEventDelta med);
     /// Specification for this propagator
@@ -375,12 +375,12 @@ namespace Gecode { namespace Int { namespace Count {
     using BaseView<VX,VY,VZ,shr>::atmost;
 
     /// Constructor for cloning \a p
-    NqView(Space* home, bool shr, NqView& p);
+    NqView(Space* home, bool shar, NqView& p);
   public:
     /// Constructor for creation
     NqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
     /// Create copy during cloning
-    virtual Actor* copy(Space* home, bool shr);
+    virtual Actor* copy(Space* home, bool shar);
     /// Perform propagation
     virtual ExecStatus propagate(Space* home, ModEventDelta med);
     /// Specification for this propagator
@@ -416,12 +416,12 @@ namespace Gecode { namespace Int { namespace Count {
     using BaseView<VX,VY,VZ,shr>::atmost;
 
     /// Constructor for cloning \a p
-    LqView(Space* home, bool shr, LqView& p);
+    LqView(Space* home, bool shar, LqView& p);
   public:
     /// Constructor for creation
     LqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);
     /// Create copy during cloning
-    virtual Actor* copy(Space* home, bool shr);
+    virtual Actor* copy(Space* home, bool shar);
     /// Perform propagation
     virtual ExecStatus propagate(Space* home, ModEventDelta med);
     /// Specification for this propagator
@@ -457,7 +457,7 @@ namespace Gecode { namespace Int { namespace Count {
     using BaseView<VX,VY,VZ,shr>::atmost;
 
     /// Constructor for cloning \a p
-    GqView(Space* home, bool shr, GqView& p);
+    GqView(Space* home, bool share, GqView& p);
   public:
     /// Constructor for creation
     GqView(Space* home, ViewArray<VX>& x, VY y, VZ z, int c);

data/ext/gecoder.cpp

@@ -125,7 +125,7 @@ namespace Gecode {
    * 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(MSpace* space, const Search::Options &o) : Gecode::DFS<MSpace>(space, o) {
   }
 
   MDFS::~MDFS() {
@@ -143,39 +143,35 @@ namespace Gecode {
 
   namespace Search {
     /* 
-     * MStop combines the time stop and fail stop, but for what reason?
-     * TODO: Try removing MStop, replacing it with plain Stop objects.
+     * MStop combines the time, memory and fail stop into one concrete 
+     * class. This is done because the bindings generator can't deal
+     * with virtual classes.
      */
 
     struct MStop::Private {
       Gecode::Search::TimeStop* ts;
       Gecode::Search::FailStop* fs;
+      Gecode::Search::MemoryStop* ms;
     };
 
     MStop::MStop() : d(new Private) {
       d->ts = 0;
       d->fs = 0;
+      d->ms = 0;
     }
 
-    MStop::MStop(int fails, int time) : d(new Private) {
+    MStop::MStop(int fails, int time, size_t mem) : d(new Private) {
       d->ts = new Search::TimeStop(time);
       d->fs = new Search::FailStop(fails);
+      d->ms = new Search::MemoryStop(mem);
     }
 
     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);
+      if (!d->fs && !d->ts && !d->ms) return false;
+      return d->fs->stop(s) || d->ts->stop(s) || d->ms->stop(s);
     }
   }
 }

data/ext/gecoder.h

@@ -58,9 +58,9 @@ namespace Gecode {
       Gecode::SetVarArray set_variables;
   };
   
-  class MDFS : public Gecode::Search::DFS {
+  class MDFS : public Gecode::DFS<MSpace> {
     public:
-      MDFS(MSpace *space, unsigned int c_d, unsigned int a_d, Search::Stop* st = 0);
+      MDFS(MSpace *space, const Search::Options &o);
       ~MDFS();
   };
 
@@ -72,15 +72,12 @@ namespace Gecode {
 
   namespace Search {
     class MStop : public Gecode::Search::Stop {
-      private:
-        MStop(int fails, int time);
-
       public:
         MStop();
+        MStop(int fails, int time, size_t mem);
         ~MStop();
 
         bool stop (const Gecode::Search::Statistics &s);
-        static Gecode::Search::Stop* create(int fails, int time);
 
       private:
         struct Private;

data/lib/gecoder/bindings/bindings.rb

@@ -38,10 +38,10 @@ Gecode::IntArgs ruby2Gecode_IntArgs(VALUE arr, int argn = -1);
 Gecode::IntArgs ruby2Gecode_IntArgs(VALUE arr, int argn)
 {
   RArray *array = RARRAY(arr);
-  Gecode::IntArgs intargs(array->len);
-  for(int i = 0; i < array->len; i++)
+  Gecode::IntArgs intargs(RARRAY_LEN(array));
+  for(int i = 0; i < RARRAY_LEN(array); i++)
   {
-    intargs[i] = NUM2INT(array->ptr[i]);
+    intargs[i] = NUM2INT(RARRAY_PTR(array)[i]);
   }
   
   return intargs;
@@ -628,12 +628,11 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       klass.bindname = "DFS"
       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"
+        method.add_parameter "Gecode::Search::Options", "o"
       end
       
       klass.add_method "next", "Gecode::MSpace *"
+      klass.add_method "stopped", "bool"
       klass.add_method "statistics", "Gecode::Search::Statistics"
     end
     
@@ -645,6 +644,7 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       end
       
       klass.add_method "next", "Gecode::MSpace *"
+      klass.add_method "stopped", "bool"
       klass.add_method "statistics", "Gecode::Search::Statistics"
     end
 
@@ -705,6 +705,11 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       searchns.add_cxx_class "MStop" do |klass|
         klass.bindname = "Stop"
         klass.add_constructor
+        klass.add_constructor do |method|
+          method.add_parameter "int", "fails"
+          method.add_parameter "int", "time"
+          method.add_parameter "int", "mem"
+        end
       end
       
       searchns.add_cxx_class "Statistics" do |klass|

data/lib/gecoder/interface/constraints.rb

@@ -120,6 +120,10 @@ module Gecode
   # See e.g. Gecode::Int::IntConstraintReceiver for 
   # concrete examples of options being specified.
   class ConstraintReceiver
+    # A list that keeps track of all constraint methods used in the
+    # program, essentially providing unique ids for each.
+    @@constraint_names_list ||= []
+
     # Constructs a new expression with the specified parameters. The 
     # parameters should at least contain the keys :lhs, and :negate.
     #
@@ -150,8 +154,12 @@ module Gecode
     # The original constraint method is assumed to take two arguments:
     # a right hand side and a hash of options.
     def self.provide_commutativity(constraint_name, &block)
-      unique_id = constraint_name.to_sym.to_i
-      pre_alias_method_name = 'pre_commutivity_' << unique_id.to_s
+      unless @@constraint_names_list.include? constraint_name
+        @@constraint_names_list << constraint_name 
+      end
+      unique_id = @@constraint_names_list.index(constraint_name)
+
+      pre_alias_method_name = "pre_commutivity_#{unique_id}"
       if method_defined? constraint_name
         alias_method pre_alias_method_name, constraint_name
       end

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

@@ -86,10 +86,14 @@ module Gecode
     # FalseClass or Enumerable.
     def self.internal_parse_regexp(arg)
       case arg 
-        when Gecode::Raw::REG: arg
-        when Fixnum: Gecode::Raw::REG.new(arg)
-        when TrueClass: Gecode::Raw::REG.new(1)
-        when FalseClass: Gecode::Raw::REG.new(0)
+        when Gecode::Raw::REG
+          arg
+        when Fixnum
+          Gecode::Raw::REG.new(arg)
+        when TrueClass
+          Gecode::Raw::REG.new(1)
+        when FalseClass
+          Gecode::Raw::REG.new(0)
         when Enumerable
           # Recursively convert the elements of the arg.
           arg.inject(Gecode::Raw::REG.new) do |regexp, element|

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

@@ -48,8 +48,9 @@ module Gecode::Set
       end
 
       case options.keys.first
-        when :substitutions: subs = options[:substitutions]
-        when :weights:
+        when :substitutions
+          subs = options[:substitutions]
+        when :weights
           weights = options[:weights]
           subs = Hash.new do |hash, key|
             if weights[key].nil?

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

@@ -1,7 +1,7 @@
 module Gecode::SetEnum
   class SetEnumConstraintReceiver
     # Constrains this set enum to channel +int_enum_operand+. The i:th set 
-    # in the enumeration of set operands is constrained to includes the value 
+    # in the enumeration of set operands is constrained to include the value 
     # of the j:th integer operand. 
     #
     # Neither reification nor negation is supported.

data/lib/gecoder/interface/search.rb

@@ -6,15 +6,32 @@ module Gecode
       super('No solution could be found.')
     end
   end
+  
+  # An exception raised when a search has been aborted due to e.g.
+  # hitting the time limit specified when initiating the search.
+  class SearchAbortedError < RuntimeError
+    def initialize #:nodoc:
+      super('The search was aborted before a solution could be found.')
+    end
+  end
 
   module Mixin
     # Finds the first solution to the modelled problem and updates the variables
     # to that solution. The found solution is also returned. Raises
     # Gecode::NoSolutionError if no solution can be found.
-    def solve!
-      dfs = dfs_engine
+    #
+    # The following options can be specified in a hash with symbols as
+    # keys when calling the method:
+    # 
+    # [:time_limit] The number of milliseconds that the solver should be
+    #               allowed to use when searching for a solution. If it can 
+    #               not find a solution fast enough, then 
+    #               Gecode::SearchAbortedError is raised.
+    def solve!(options = {})
+      dfs = dfs_engine(options)
       space = dfs.next
       @gecoder_mixin_statistics = dfs.statistics
+      raise Gecode::SearchAbortedError if dfs.stopped
       raise Gecode::NoSolutionError if space.nil?
       self.active_space = space
       return self
@@ -184,15 +201,29 @@ module Gecode
     
     # Creates a depth first search engine for search, executing any 
     # unexecuted constraints first.
-    def dfs_engine
+    def dfs_engine(options = {})
       # Execute constraints.
       perform_queued_gecode_interactions
       
+      # Begin constructing the option struct.
+      opt_struct = Gecode::Raw::Search::Options.new
+      opt_struct.c_d = Gecode::Raw::Search::Config::MINIMAL_DISTANCE
+      opt_struct.a_d = Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE
+
+      # Decode the options.
+      if options.has_key? :time_limit
+        opt_struct.stop = Gecode::Raw::Search::Stop.new(-1, options.delete(:time_limit), -1)
+      else
+        opt_struct.stop = nil
+      end
+      
+      unless options.empty?
+        raise ArgumentError, 'Unrecognized search option: ' + 
+          options.keys.first.to_s
+      end
+
       # Construct the engine.
-      Gecode::Raw::DFS.new(selected_space, 
-        Gecode::Raw::Search::Config::MINIMAL_DISTANCE,
-        Gecode::Raw::Search::Config::ADAPTIVE_DISTANCE, 
-        nil)
+      Gecode::Raw::DFS.new(selected_space, opt_struct)
     end
   end
 end

data/lib/gecoder/version.rb

@@ -1,4 +1,4 @@
 module GecodeR #:nodoc:
   # A string representation of the Gecode/R version.
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/specs/search.rb

@@ -21,6 +21,23 @@ class SampleProblem
   end
 end
 
+class DifficultSampleProblem
+  include Gecode::Mixin
+
+  def initialize
+    # The magic sequence problem with a large n.
+    n = 500
+    sequence_is_an int_var_array(n, 0...n)
+    n.times{ |i| sequence.count(i).must == sequence[i] }
+    sequence.inject{ |x,y| x + y }.must == n
+    sequence.zip((-1...n).to_a).map do |element, c| 
+      element*c
+    end.inject{ |x,y| x + y }.must == 0
+
+    branch_on sequence, :variable => :smallest_degree, :value => :split_max
+  end
+end
+
 class SampleOptimizationProblem
   include Gecode::Mixin
 
@@ -387,3 +404,29 @@ describe Gecode::Mixin, '(single variable maximization)' do
   it_should_behave_like 'single variable optimization'
 end
 
+describe Gecode::Mixin, ' (with time limitations)' do
+  it 'should not time out problems that finish within the time limitation' do
+    @domain = 0..3
+    @solved_domain = [2]
+    @model = SampleProblem.new(@domain)
+    lambda do
+      @model.solve!(:time_limit => 50)
+    end.should_not raise_error(Gecode::SearchAbortedError)
+  end
+  
+  it 'should time out problems that do not finish within the time limitation' do
+    @model = DifficultSampleProblem.new
+    lambda do
+      t = Time.now
+      @model.solve!(:time_limit => 50)
+      puts Time.now - t
+    end.should raise_error(Gecode::SearchAbortedError)
+  end
+  
+  it 'should raise error if an unrecognised option is passed' do
+    @model = DifficultSampleProblem.new
+    lambda do
+      @model.solve!(:time_limit => 50, :foo => 1)
+    end.should raise_error(ArgumentError)
+  end
+end

data/tasks/distribution.rake

@@ -18,18 +18,20 @@ rd = Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'doc/output/rdoc'
   rdoc.title = 'Gecode/R'
   rdoc.template = 'doc/rdoc/jamis.rb'
-  rdoc.options << '--line-numbers' << '--inline-source' << 
+  rdoc.options << '--line-numbers' << '--inline-source' <<
     '--accessor' << 'delegate' << '--main' << 'README'
   rdoc.rdoc_files.include('README', 'CHANGES', 'THANKS', 'LGPL-LICENSE', 'lib/**/*.rb')
 end
 
+# Removing this, which apparently doesn't work due to an update to RDoc.
+=begin
 TMP_DIR = 'doc/tmp/rdoc_dev'
 desc 'Generate RDoc, ignoring nodoc'
 Rake::RDocTask.new(:rdoc_dev => :prepare_rdoc_dev) do |rdoc|
   rdoc.rdoc_dir = 'doc/output/rdoc_dev'
-  rdoc.options << '--title' << 'Gecode/R Developers RDoc' << '--line-numbers' << 
+  rdoc.options << '--title' << 'Gecode/R Developers RDoc' << '--line-numbers' <<
     '--inline-source' << '--accessor' << 'delegate'
-  
+
   rdoc.rdoc_files.include("#{TMP_DIR}/**/*.rb")
 end
 
@@ -46,6 +48,7 @@ task :prepare_rdoc_dev do
     destination.close
   end
 end
+=end
 
 desc 'Extracts the source of Gecode before it is packaged into a gem'
 task :extract_gecode do
@@ -53,25 +56,25 @@ task :extract_gecode do
   cd(EXT_DIR) do
     cp "../#{GECODE_DIR}/#{GECODE_ARCHIVE_NAME}", GECODE_ARCHIVE_NAME
     system("tar -xvf #{GECODE_ARCHIVE_NAME}")
-    rm GECODE_ARCHIVE_NAME 
+    rm GECODE_ARCHIVE_NAME
   end
 end
 # To ensure that the Gecode files exist for the gem spec.
-Rake::Task['extract_gecode'].invoke 
+Rake::Task['extract_gecode'].invoke
 
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
   s.version = GecodeR::VERSION
   s.summary = 'Ruby interface to Gecode, an environment for constraint programming.'
   s.description = <<-end_description
-    Gecode/R is a Ruby interface to the Gecode constraint programming library. 
-    Gecode/R is intended for people with no previous experience of constraint 
+    Gecode/R is a Ruby interface to the Gecode constraint programming library.
+    Gecode/R is intended for people with no previous experience of constraint
     programming, aiming to be easy to pick up and use.
   end_description
 
   s.files = FileList[
     '[A-Z]*',
-    'lib/**/*.rb', 
+    'lib/**/*.rb',
     'example/**/*.rb',
     'src/**/*',
     'vendor/rust/**/*',
@@ -98,12 +101,12 @@ spec = Gem::Specification.new do |s|
 =begin
   # Development dependencies.
   # Not listed: rubygems >= 1.2
-  [['rake'], 
-    ['webgen', '= 0.4.7'], 
-    ['coderay'], 
-    ['rspec', '>= 1.0'], 
-    ['rcov'], 
-    ['meta_project'], 
+  [['rake'],
+    ['webgen', '= 0.4.7'],
+    ['coderay'],
+    ['rspec', '>= 1.0'],
+    ['rcov'],
+    ['meta_project'],
     ['rubyforge']].each do |dependency|
     s.add_development_dependency(*dependency)
   end
@@ -117,17 +120,17 @@ spec_windows_binary_with_gecode.extensions = []
 spec_windows_binary_with_gecode.requirements = []
 # Add the precompiled Gecode DLLs and precompiled bindings.
 spec_windows_binary_with_gecode.files = spec.files.dup -
-  FileList['ext/**/*'].to_a + 
+  FileList['ext/**/*'].to_a +
   FileList['vendor/gecode/win32/lib/*'].to_a << 'lib/gecode.dll'
 spec_windows_binary_with_gecode.platform = 'x86-mswin32-60' #Gem::Platform::WIN32
 
 # Create a clone of the gem spec that includes Gecode.
 spec_with_gecode = spec.dup
 spec_with_gecode.name = PKG_NAME_WITH_GECODE
-spec_with_gecode.extensions = 
+spec_with_gecode.extensions =
   spec_with_gecode.extensions.dup.unshift 'ext/gecode-2.2.0/configure'
 spec_with_gecode.requirements = []
-spec_with_gecode.files = spec.files.dup + FileList['ext/gecode-*/**/*'].to_a 
+spec_with_gecode.files = spec.files.dup + FileList['ext/gecode-*/**/*'].to_a
 
 desc 'Generate Gecode/R Gem'
 Rake::GemPackageTask.new(spec) do |pkg|
@@ -141,9 +144,11 @@ Rake::GemPackageTask.new(spec_with_gecode) do |pkg|
   pkg.need_tar = true
 end
 
+=begin
 desc 'Generate Gecode/R + Gecode Gem (windows binary)'
 Rake::GemPackageTask.new(spec_windows_binary_with_gecode) do |pkg|
 end
+=end
 
 desc 'Precompiles the Gecode/R bindings for Windows platforms'
 file 'lib/gecode.dll' do
@@ -168,7 +173,7 @@ task :clobber do
 end
 
 desc 'Publish packages on RubyForge'
-task :publish_packages => [:publish_gecoder_packages, 
+task :publish_packages => [:publish_gecoder_packages,
   :publish_gecoder_with_gecode_packages]
 
 # Files included in the vanilla Gecode/R release.
@@ -195,13 +200,13 @@ gecode_release_files = [
   "pkg/#{PKG_FILE_NAME_WITH_GECODE}.gem",
   #"pkg/#{PKG_FILE_NAME_WITH_GECODE}.tgz",
   #"pkg/#{PKG_FILE_NAME_WITH_GECODE}.zip",
-  "pkg/#{PKG_FILE_NAME_WITH_GECODE}-x86-mswin32-60.gem"
+  #"pkg/#{PKG_FILE_NAME_WITH_GECODE}-x86-mswin32-60.gem"
 ]
 gecode_release_files.each do |pkg|
   file pkg => :extract_gecode
 end
 desc 'Publish Gecode/R with Gecode packages on RubyForge'
-task :publish_gecoder_with_gecode_packages => 
+task :publish_gecoder_with_gecode_packages =>
     [:verify_user] + gecode_release_files do
   require 'meta_project'
   require 'rake/contrib/xforge'