gecoder 0.2.0

data/lib/gecoder/interface/enum_wrapper.rb

@@ -0,0 +1,64 @@
+module Gecode
+  class Model
+    private
+    
+    # Wraps a custom enumerable so that constraints can be specified using it.
+    # The argument is altered and returned. 
+    def wrap_enum(enum)
+      unless enum.kind_of? Enumerable
+        raise TypeError, 'Only enumerables can be wrapped.'
+      end
+      
+      class <<enum
+        include Gecode::IntEnumConstraintMethods
+      end
+      enum.model = self
+      return enum
+    end
+  end
+  
+  # A module containing the methods needed by enumerations containing int 
+  # variables. Requires that it's included in an enumerable.
+  module IntEnumConstraintMethods
+    # Specifies that a constraint must hold for the integer variable enum.
+    def must
+      IntVarEnumConstraintExpression.new(active_space, to_int_var_array)
+    end
+    alias_method :must_be, :must
+    
+    # Specifies that the negation of a constraint must hold for the integer 
+    # variable.
+    def must_not
+      IntVarEnumConstraintExpression.new(active_space, to_int_var_array, 
+        true)
+    end
+    alias_method :must_not_be, :must_not
+    
+    # Returns an int variable array with all the bound variables.
+    def to_int_var_array
+      elements = to_a
+      arr = Gecode::Raw::IntVarArray.new(active_space, elements.size)
+      elements.each_with_index{ |var, index| arr[index] = var.bind }
+      return arr
+    end
+    
+    attr_accessor :model
+    # Gets the current space of the model the array is connected to.
+    def active_space
+      @model.active_space
+    end
+  end
+  
+  # Describes a constraint expression that starts with an enumeration of int
+  # variables followed by must or must_not.
+  class IntVarEnumConstraintExpression
+    # Constructs a new expression with the specified space and int var array 
+    # with the (bound) variables as source. The expression can optionally be 
+    # negated.
+    def initialize(space, var_array, negate = false)
+      @space = space
+      @var_array = var_array
+      @negate = negate
+    end
+  end
+end

data/lib/gecoder/interface/model.rb

@@ -0,0 +1,130 @@
+module Gecode
+  # Model is the base class that all models must inherit from. The superclass
+  # constructor must be called.
+  class Model
+    # Design notes: Only one model per problem is used. A model has multiple 
+    # spaces. A model has a base space in which it sets up during the 
+    # initialization. The model binds the int variables to the current space 
+    # upon use.
+  
+    # The base from which searches are made. 
+    attr :base_space
+    # The currently active space (the one which variables refer to).
+    attr :active_space
+    
+    def initialize
+      @active_space = @base_space = Gecode::Raw::Space.new
+    end
+    
+    # Creates a new integer variable with the specified domain. The domain can
+    # either be a range or a number of elements. 
+    def int_var(*domain_args)
+      range = domain_range(*domain_args)
+      index = active_space.new_int_vars(range.begin, range.end).first
+      construct_int_var(index, *domain_args)
+    end
+    
+    # Creates an array containing the specified number of integer variables 
+    # with the specified domain. The domain can either be a range or a number 
+    # of elements. 
+    def int_var_array(count, *domain_args)
+      # TODO: Maybe the custom domain should be specified as an array instead? 
+      
+      range = domain_range(*domain_args)
+      variables = []
+      active_space.new_int_vars(range.begin, range.end, count).each do |index|
+        variables << construct_int_var(index, *domain_args)
+      end
+      return wrap_enum(variables)
+    end
+    
+    private
+    
+    # Returns the range of the specified domain arguments, which can either be
+    # given as a range or a number of elements. Raises ArgumentError if no 
+    # arguments have been specified. 
+    def domain_range(*domain_args)
+      min = max = nil
+      if domain_args.empty?
+        raise ArgumentError, 'A domain has to be specified.'
+      elsif domain_args.size > 1
+        min = domain_args.min
+        max = domain_args.max
+      else
+        element = domain_args.first
+        if element.respond_to? :begin and element.respond_to? :end
+          min = element.begin
+          max = element.end
+        else
+          min = max = element
+        end
+      end
+      return min..max
+    end
+    
+    # Creates an integer variable from the specified index and domain. The 
+    # domain can either be given as a range or as a number of elements.
+    def construct_int_var(index, *domain_args)
+      var = FreeIntVar.new(self, index)
+      
+      if domain_args.size > 1
+        # Place an additional domain constraint on the variable with the 
+        # arguments as domain.
+        # TODO: use the model's way of defining domain constraints when 
+        # available.
+        domain_set = Gecode::Raw::IntSet.new(domain_args, domain_args.size)
+        Gecode::Raw::dom(active_space, var.bind, domain_set, 
+          Gecode::Raw::ICL_DEF)
+      end
+      return var
+    end
+  end
+  
+  # An IntVar that is bound to a model, but not to a particular space.  
+  class FreeIntVar
+    attr_accessor :model
+  
+    # Creates an int variable with the specified index.
+    def initialize(model, index)
+      @model = model
+      @index = index
+      @bound_space = @bound_var = nil
+    end
+    
+    # Delegate methods we can't handle to the bound int variable if possible.
+    def method_missing(name, *args)
+      if Gecode::Raw::IntVar.instance_methods.include? name.to_s
+        bind.send(name, *args)
+      else
+        super
+      end
+    end
+    
+    # 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.int_var(@index)
+        @bound_space = space
+      end
+      return @bound
+    end
+    
+    def inspect
+      if assigned?
+        "#<FreeIntVar range: val.to_s>"
+      else
+        "#<FreeIntVar range: #{min}..#{max}>"
+      end
+    end
+    
+    private
+    
+    # Returns the space that the int variable should bind to when needed.
+    def active_space
+      @model.active_space
+    end
+  end
+end

data/lib/gecoder/interface/search.rb

@@ -0,0 +1,23 @@
+module Gecode
+  class Model
+    private
+    
+    # Used during the search.
+    COPY_DIST = 16
+    ADAPTATION_DIST = 4 
+    
+    public
+
+    # Finds the first solution to the modelled problem and updates the variables
+    # to that solution. Returns the model if a solution was found, nil 
+    # otherwise.
+    def solve!
+      stop = Gecode::Raw::Search::Stop.new
+      dfs = Gecode::Raw::DFS.new(@base_space, COPY_DIST, ADAPTATION_DIST, stop)
+      space = dfs.next
+      return nil if space.nil?
+      @active_space = space
+      return self
+    end
+  end
+end

data/vendor/rust/README

@@ -0,0 +1,28 @@
+When I wanted to write a GUI tagger for KDE using Korundum (KDE Ruby
+bindings), I discovered to my sadness that most of the tagging
+extensions for Ruby were simple bindings for the C interface of the
+most common TagLib library (that is written in C++ instead); writing
+bindings for the C++ interface was quite a complex task, and boring as
+it was to copy and paste the same code over and over.
+
+For this reason I started first writing a simple extensions generator
+that used a YAML description of the namespaces and the classes to
+write bindings for. This method worked fine for what I was working on
+(RubyTag++), and also allowed me to write quite quickly some Ruby
+bindings for Hunspell too.
+
+Unfortunately this generator was not adaptable enough to write
+bindings for C libraries that used some object oriented interfaces,
+and was a mess to extend to provide bindings more suitable to some
+different cases than the ones I've already used the script for.
+
+For this reason I've started working on Rust: a more flexible
+extensions builder, that allowed to bind even C libraries by faking
+some classes on Ruby (although I haven't implemented this yet).
+
+Hopefully in the future Rust can be used to easily produce Ruby
+bindings for a number of libraries that currently aren't available at
+all.
+
+To contact me, send me patches or comments, just write to
+<flameeyes@gmail.com> .

data/vendor/rust/bin/cxxgenerator.rb

@@ -0,0 +1,93 @@
+
+require 'rust/cppifaceparser'
+
+
+if __FILE__ == $0
+  def usage
+    puts "Use: #{File.basename($0)} [header] [module name] [output file]"
+  end
+  
+  parser = Rust::Cpp::IfaceParser.new
+  
+  if ARGV.size != 3 or not File.exists?(ARGV[0].to_s)
+    usage
+    exit 0
+  end
+  
+  header = ARGV[0]
+  namespace = ARGV[1]
+  outputfile = ARGV[2]
+  outputfile += ".rb" if not outputfile =~ /\.rb$/
+  
+  classes = parser.parseFile(header)
+  
+  rust = %@
+require 'rust'
+
+Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "#{namespace}" do |b|
+  b.include_header '#{header}', Rust::Bindings::HeaderGlobal
+  b.add_namespace "#{namespace}", "" do |ns|
+@
+  classes.each { |klass|
+    rust += %@  ns.add_cxx_class "#{klass[:name]}" do |klass|\n@
+    klass[:constructors].each { |constructor|
+      rust += "    klass.add_constructor "
+      if not constructor[:params].empty? and not constructor[:params].detect { |p| p[:type] =~ /void/ }
+        rust += "do |method|\n"
+        constructor[:params].each { |param|
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "    end"
+      end
+      rust += "\n"
+    }
+    
+    klass[:methods].each { |method|
+      comment_method = false
+      if method[:params].detect { |p| p[:type] =~ /\s*\*\s*\*/ }
+        $stderr << "Ignoring method: #{method[:name]}\n"
+        comment_method = true
+      end
+      
+      rust += "# " if comment_method
+      rust += %@    klass.add_method "#{method[:name]}", "#{method[:type]}"@
+      if not method[:params].empty? and not method[:params].detect { |p| p[:type] =~ /void/ }
+        rust += " do |method|\n" if not method[:params].empty?
+        
+        
+        method[:params].each { |param|
+          rust += "# " if comment_method
+          rust += %@      method.add_parameter "#{param[:type]}", "#{param[:name]}"\n@
+        }
+        rust += "# " if comment_method
+        rust += "    end"
+      end
+      
+      rust += "\n"
+    }
+    rust += "    end\n" 
+  }
+  
+  rust += %@
+  end
+end
+@
+  
+  File.open( outputfile, "w" ) { |f|
+    f << rust << "\n"
+  }
+  
+  # Create configure.rb
+  File.open( File.dirname(outputfile)+"/configure.rb", "w" ) { |f|
+    f << %@
+require 'mkmf'
+find_header("rust_conversions.hh", "./include" )
+eval File.open("#{File.basename(outputfile)}").readlines.to_s
+create_makefile("#{namespace}")
+    @
+  }
+  
+end
+
+
+

data/vendor/rust/include/rust_checks.hh

@@ -0,0 +1,115 @@
+/* Copyright (c) 2007 David Cuadrado <krawek@gmail.com>
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE
+ * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __RUST_CHECKS__
+#define __RUST_CHECKS__
+
+#include <ruby.h>
+
+static inline void rust_CheckType(VALUE *a)
+{
+	Check_Type(a[0], NUM2INT(a[1]));
+}
+
+static inline bool isType(VALUE val, int type)
+{
+  int result;
+  if( type == 0x0 ) return false;
+  
+  VALUE args[2];
+  args[0] = (VALUE)val;
+  args[1] = INT2FIX(type);
+  
+  rb_protect( (VALUE(*)(VALUE))rust_CheckType, (VALUE)args, &result);
+  return result == 0;
+}
+
+
+static inline bool is_object(VALUE val)
+{
+  return isType(val, T_OBJECT);
+}
+
+static inline bool is_class(VALUE val)
+{
+  return isType(val, T_CLASS);
+}
+
+static inline bool is_module(VALUE val)
+{
+  return isType(val, T_MODULE);
+}
+
+static inline bool is_fLoat(VALUE val)
+{
+  return isType(val, T_FLOAT);
+}
+
+static inline bool is_string(VALUE val)
+{
+  return isType(val, T_STRING);
+}
+
+static inline bool is_regexp(VALUE val)
+{
+  return isType(val, T_REGEXP);
+}
+
+static inline bool is_array(VALUE val)
+{
+  return isType(val, T_ARRAY);
+}
+
+static inline bool is_int(VALUE val)
+{
+  return isType(val, T_FIXNUM);
+}
+
+static inline bool is_hash(VALUE val)
+{
+  return isType(val, T_HASH);
+}
+
+static inline bool is_symbol(VALUE val)
+{
+  return isType(val, T_SYMBOL);
+}
+
+static inline bool is_bool(VALUE val)
+{
+  return val == Qtrue || val == Qfalse;
+}
+
+static inline bool is_charPtr(VALUE val)
+{
+  char *c = 0;
+  c = reinterpret_cast<char *>(DATA_PTR(val));
+  
+  return c != 0; // FIXME
+}
+
+
+
+
+#endif 
+