gecoder-with-gecode 0.9.0-x86-mswin32-60 → 0.9.1-x86-mswin32-60

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

@@ -5,19 +5,19 @@ module Gecode::IntEnum #:nodoc:
   # constraints defined in IntEnumConstraintReceiver can be placed.
   #
   # Enumerations of integer operands can be created either by using
-  # Gecode::Model#int_var_array and Gecode::Model#int_var_matrix, or
+  # Gecode::Mixin#int_var_array and Gecode::Mixin#int_var_matrix, or
   # by wrapping an existing enumeration containing IntOperand using
-  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # Gecode::Mixin#wrap_enum. The enumerations, no matter how they were
   # created, all respond to the properties defined by IntEnumOperand.
   #
   # ==== Examples 
   #
   # Produces an array of five int operands with domain 0..9 inside a 
-  # problem formulation using Gecode::Model#int_var_array:
+  # problem formulation using Gecode::Mixin#int_var_array:
   #
   #   int_enum = int_var_array(5, 0..9)
   #
-  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # Uses Gecode::Mixin#wrap_enum inside a problem formulation to create
   # a IntEnumOperand from an existing enumeration containing the
   # integer operands +int_operand1+ and +int_operand2+:
   #

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

@@ -5,7 +5,7 @@ module Gecode::Int #:nodoc:
   # constraints defined in IntConstraintReceiver can be placed.
   #
   # Integer operands can be created either by using
-  # Gecode::Model#int_var et al, or by using properties that produce
+  # Gecode::Mixin#int_var et al, or by using properties that produce
   # integer operands. The operands, no matter how they were created, 
   # all respond to the properties defined by IntOperand.
   #
@@ -13,7 +13,7 @@ module Gecode::Int #:nodoc:
   #
   # Produces a single integer operand (more specifically an IntVar) with
   # domain 0..9 inside a problem formulation, using
-  # Gecode::Model#int_var:
+  # Gecode::Mixin#int_var:
   #
   #   int_operand = int_var(0..9)
   #

data/lib/gecoder/interface/constraints/selected_set/select.rb

@@ -7,7 +7,7 @@ module Gecode::SelectedSet
     #   # The union of all sets selected by +set_enum[set]+.
     #   set_enum[set].union
     def union
-      Select::SelectedSetUnionOperand.new(model, self)
+      Element::SelectedSetUnionOperand.new(model, self)
     end
      
     # Produces a SetOperand representing the selected sets' intersection.
@@ -36,7 +36,7 @@ module Gecode::SelectedSet
         end
       end
       
-      Select::SelectedSetIntersectionOperand.new(model, self, universe)
+      Element::SelectedSetIntersectionOperand.new(model, self, universe)
     end
   end
 
@@ -59,11 +59,11 @@ module Gecode::SelectedSet
       end
 
       @params.update Gecode::Set::Util.decode_options(options)
-      @model.add_constraint Select::DisjointConstraint.new(@model, @params)
+      @model.add_constraint Element::DisjointConstraint.new(@model, @params)
     end
   end
 
-  module Select #:nodoc:
+  module Element #:nodoc:
     class SelectedSetUnionOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
       def initialize(model, selected_set)
         super model
@@ -76,7 +76,7 @@ module Gecode::SelectedSet
           set_operand.must_be.subset_of enum.upper_bound_range
         end
         
-        Gecode::Raw::selectUnion(@model.active_space, 
+        Gecode::Raw::elementsUnion(@model.active_space, 
           enum.to_set_enum.bind_array, indices.to_set_var.bind, 
           set_operand.to_set_var.bind)
       end
@@ -97,11 +97,11 @@ module Gecode::SelectedSet
         # is the universe.
 
         if universe.nil?
-          Gecode::Raw::selectInter(@model.active_space, 
+          Gecode::Raw::elementsInter(@model.active_space, 
             enum.to_set_enum.bind_array, indices.to_set_var.bind, 
             set_operand.to_set_var.bind)
         else
-          Gecode::Raw::selectInterIn(@model.active_space,  
+          Gecode::Raw::elementsInter(@model.active_space,  
             enum.to_set_enum.bind_array, indices.to_set_var.bind, 
             set_operand.to_set_var.bind,
             Gecode::Util.constant_set_to_int_set(universe))
@@ -112,7 +112,7 @@ module Gecode::SelectedSet
     class DisjointConstraint < Gecode::Constraint #:nodoc:
       def post
         enum, indices = @params[:lhs].to_selected_set
-        Gecode::Raw.selectDisjoint(@model.active_space, 
+        Gecode::Raw.elementsDisjoint(@model.active_space, 
           enum.to_set_enum.bind_array, indices.to_set_var.bind)
       end
     end

data/lib/gecoder/interface/constraints/set_enum/{select.rb → element.rb}

@@ -7,14 +7,14 @@ module Gecode::SetEnum
       mod.module_eval do
         # Now we enter the module SetEnumOperands is mixed into.
         class << self
-          alias_method :pre_selection_included, :included
+          alias_method :pre_set_element_included, :included
           def included(mod) #:nodoc:
             mod.module_eval do
               # Now we enter the module that the module possibly defining #[] 
               # is mixed into.
               if instance_methods.include?('[]') and 
-                  not instance_methods.include?('pre_selection_access')
-                alias_method :pre_selection_access, :[]
+                  not instance_methods.include?('pre_set_element_access')
+                alias_method :pre_set_element_access, :[]
               end
             
               # Produces a SetOperand representing the i:th set
@@ -38,27 +38,27 @@ module Gecode::SetEnum
                 # Hook in an element constraint if a operand is used for array 
                 # access.
                 if vars.first.respond_to? :to_int_var
-                  Select::SelectSetOperand.new(
+                  Element::ElementSetOperand.new(
                     model, self, vars.first)
                 elsif vars.first.respond_to? :to_set_var
                   Gecode::SelectedSet::SelectedSetOperand.new(
                     self, vars.first)
                 else
-                  if respond_to? :pre_selection_access
-                    pre_selection_access(*vars) 
+                  if respond_to? :pre_set_element_access
+                    pre_set_element_access(*vars) 
                   end
                 end
               end
             end
-            pre_selection_included(mod)
+            pre_set_element_included(mod)
           end
         end
       end
     end
   end
 
-  module Select #:nodoc:
-    class SelectSetOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+  module Element #:nodoc:
+    class ElementSetOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
       def initialize(model, enum_op, position_int_op)
         super model
         @enum = enum_op
@@ -71,7 +71,7 @@ module Gecode::SetEnum
           set_operand.must_be.subset_of enum.upper_bound_range
         end
 
-        Gecode::Raw::selectSet(@model.active_space, enum.bind_array, 
+        Gecode::Raw::element(@model.active_space, enum.bind_array, 
           @position.to_int_var.bind, set_operand.to_set_var.bind)
       end
     end

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

@@ -5,20 +5,20 @@ module Gecode::SetEnum #:nodoc:
   # constraints defined in SetEnumConstraintReceiver can be placed.
   #
   # Enumerations of set operands can be created either by using
-  # Gecode::Model#set_var_array and Gecode::Model#set_var_matrix, or
+  # Gecode::Mixin#set_var_array and Gecode::Mixin#set_var_matrix, or
   # by wrapping an existing enumeration containing SetOperand using
-  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # Gecode::Mixin#wrap_enum. The enumerations, no matter how they were
   # created, all respond to the properties defined by SetEnumOperand.
   #
   # ==== Examples 
   #
   # Produces an array of five set operands, with greatest lower bound
   # {0} and least upper bound {0, 1, 2}, inside a problem formulation
-  # using Gecode::Model#set_var_array:
+  # using Gecode::Mixin#set_var_array:
   #
   #   set_enum = set_var_array(5, 0, 1..2)
   #
-  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # Uses Gecode::Mixin#wrap_enum inside a problem formulation to create
   # a SetEnumOperand from an existing enumeration containing the
   # set operands +set_operand1+ and +set_operand2+:
   #
@@ -80,5 +80,5 @@ end
 
 require 'gecoder/interface/constraints/set_enum/channel'
 require 'gecoder/interface/constraints/set_enum/distinct'
-require 'gecoder/interface/constraints/set_enum/select'
+require 'gecoder/interface/constraints/set_enum/element'
 require 'gecoder/interface/constraints/set_enum/operation'

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

@@ -4,7 +4,7 @@ module Gecode::Set #:nodoc:
   # A SetOperand is a combination of operands on which the
   # constraints defined in SetConstraintReceiver can be placed.
   #
-  # Set operands can be created either by using Gecode::Model#set_var et
+  # Set operands can be created either by using Gecode::Mixin#set_var et
   # al, or by using properties that produce set operands. The operands,
   # no matter how they were created, all respond to the properties
   # defined by SetOperand.
@@ -13,7 +13,7 @@ module Gecode::Set #:nodoc:
   #
   # Produces a single set operand (more specifically a SetVar), with
   # greatest lower bound {0} and least upper bound {0, 1, 2}, inside a
-  # problem formulation, using Gecode::Model#set_var:
+  # problem formulation, using Gecode::Mixin#set_var:
   #
   #   set_operand = set_var(0, 0..2)
   #

data/lib/gecoder/interface/{model_sugar.rb → convenience.rb}

@@ -1,4 +1,11 @@
 module Gecode
+  # A convenient class that just includes Gecode::Mixin. Can be useful
+  # when you don't want to create your own class that mixes in
+  # Gecode::Mixin.
+  class Model
+    include Gecode::Mixin
+  end
+
   # Provides a convenient way to construct a model and then find a
   # solution. The model constructed uses the specified block as 
   # initialization method. The first solution to the model is then
@@ -12,7 +19,9 @@ module Gecode
   # 
   # is equivalent to
   # 
-  #   class Foo < Gecode::Model
+  #   class Foo 
+  #     include Gecode::Mixin
+  #
   #     def initialize
   #       # Do something
   #     end
@@ -35,7 +44,9 @@ module Gecode
   # 
   # is equivalent to
   # 
-  #   class Foo < Gecode::Model
+  #   class Foo 
+  #     include Gecode::Mixin
+  #
   #     def initialize
   #       # Do something
   #     end
@@ -58,7 +69,9 @@ module Gecode
   # 
   # is equivalent to
   # 
-  #   class Foo < Gecode::Model
+  #   class Foo
+  #     include Gecode::Mixin
+  #
   #     def initialize
   #       # Do something
   #     end
@@ -73,8 +86,10 @@ module Gecode
   # Creates an instance of a class that subclasses Model and uses the 
   # specified block as initialization method.
   def self.create_model(&block)
-    model = Class.new(Gecode::Model)
+    model = Class.new
     model.class_eval do
+      include Gecode::Mixin
+
       def initialize(&init_block) #:nodoc:
         instance_eval &init_block
       end

data/lib/gecoder/interface/enum_wrapper.rb

@@ -1,5 +1,5 @@
 module Gecode
-  class Model
+  module Mixin
     # Wraps a custom enumerable so that constraints can be specified using it.
     # The argument is altered and returned. 
     def wrap_enum(enum)

data/lib/gecoder/interface/{model.rb → mixin.rb}

@@ -1,11 +1,13 @@
 module Gecode
-  # Model is the base class that all models must inherit from.
+  # Mixin contains the base functionality needed to formulate problems.
   #
   # == Formulating problems
   #
-  # Models are used to formulate the problems that Gecode should solve.
-  # Below is an example of a model that formulates the problem of finding
-  # a solution to the following equation system.
+  # Problems are formulated by building a model that represents the
+  # problem. A model is a class that mixes in Mixin and uses its
+  # functionality to define variables and constraints that describe the
+  # problem. Below is an example of a model that formulates the problem
+  # of finding a solution to the following equation system.
   #
   # Equation system:
   #   x + y = z
@@ -13,7 +15,9 @@ module Gecode
   #   0 <= x,y,z <= 9
   #
   # Model:
-  #   class EquationProblem < Gecode::Model
+  #   class EquationProblem 
+  #     include Gecode::Mixin
+  #
   #     attr :vars
   #
   #     def initialize
@@ -97,7 +101,9 @@ module Gecode
   # Additionally one can use "foo_is_an ..." to create an accessor of 
   # name foo, without having to use instance variables. The above
   # problem becomes
-  #   class EquationProblem < Gecode::Model
+  #   class EquationProblem 
+  #     include Gecode::Mixin
+  #
   #     def initialize
   #       x, y, z = vars_is_an int_var_array(3, 0..9)
   #
@@ -108,7 +114,7 @@ module Gecode
   #     end
   #   end
   #
-  class Model
+  module Mixin
     # The largest integer allowed in the domain of an integer variable.
     MAX_INT = Gecode::Raw::IntLimits::MAX
     # The smallest integer allowed in the domain of an integer variable.
@@ -221,7 +227,7 @@ module Gecode
     # The space returned by this method should never be stored, it should be
     # rerequested from the model every time that it's needed.
     def active_space #:nodoc:
-      unless @allow_space_access
+      unless @gecoder_mixin_allow_space_access
         raise 'Space access is restricted and the permission to access the ' + 
           'space has not been given.'
       end
@@ -253,63 +259,90 @@ module Gecode
       # We store the old value so that nested calls don't become a problem, i.e.
       # access is allowed as long as one call to this method is still on the 
       # stack.
-      old = @allow_space_access
-      @allow_space_access = true
+      old = @gecoder_mixin_allow_space_access
+      @gecoder_mixin_allow_space_access = true
       res = yield
-      @allow_space_access = old
+      @gecoder_mixin_allow_space_access = old
       return res
     end
     
     # Starts tracking a variable that depends on the space. All variables 
     # created should call this method for their respective models.
     def track_variable(variable) #:nodoc:
-      (@variables ||= []) << variable
+      (@gecoder_mixin_variables ||= []) << variable
     end
 
-    # Wraps method missing to handle #foo_is_a and #foo_is_an . 
-    #
-    # "<variable_name>_is_a <variable>" or "<variable_name>_is_an <variable>", 
-    # replacing "<variable_name>" with the variable's name and 
-    # "<variable>" with the variable, adds an instance variable and 
-    # accessor with the specified name.
-    #
-    # The method also returns the variable given.
-    #
-    # ==== Example
-    #
-    #   # Add an instance variable and accessor named "foo" that return
-    #   # the integer variable.
-    #   foo_is_an int_var(0..9)
-    #
-    #   # Add an instance variable and accessor named "bar" that return
-    #   # the boolean variable array.
-    #   bar_is_a bool_var_array(2)
-    def method_missing(name_symbol, *args)
-      name = name_symbol.to_s
-      if name =~ /._is_an?$/
-        name.sub!(/_is_an?$/, '')
-        unless args.size == 1
-          raise ArgumentError, "Wrong number of argmuments (#{args.size} for 1)."
-        end 
-        if respond_to? name
-          raise ArgumentError, "Method with name #{name} already exists."
-        end
-        if instance_variable_defined? "@#{name}"
-          raise ArgumentError, 
-            "Instance variable with name @#{name} already exists."
+    def self.included(mod)
+      mod.class_eval do
+        alias_method :pre_gecoder_method_missing, :method_missing
+        # Wraps method missing to handle #foo_is_a and #foo_is_an . 
+        #
+        # "<variable_name>_is_a <variable>" or "<variable_name>_is_an
+        # <variable>", # replacing "<variable_name>" with the variable's
+        # name and "<variable>" with the variable, adds an instance
+        # variable and accessor with the specified name.
+        #
+        # The method also returns the variable given.
+        #
+        # ==== Example
+        #
+        #   # Add an instance variable and accessor named "foo" that return
+        #   # the integer variable.
+        #   foo_is_an int_var(0..9)
+        #
+        #   # Add an instance variable and accessor named "bar" that return
+        #   # the boolean variable array.
+        #   bar_is_a bool_var_array(2)
+        def method_missing(method, *args)
+          name = method.to_s
+          if name =~ /._is_an?$/
+            name.sub!(/_is_an?$/, '')
+            unless args.size == 1
+              raise ArgumentError, 
+                "Wrong number of argmuments (#{args.size} for 1)."
+            end 
+            if respond_to? name
+              raise ArgumentError, "Method with name #{name} already exists."
+            end
+            if instance_variable_defined? "@#{name}"
+              raise ArgumentError, 
+                "Instance variable with name @#{name} already exists."
+            end
+
+            # We use the meta class to avoid defining the variable in all
+            # other instances of the class.
+            eval <<-"end_eval"
+              @#{name} = args.first
+              class <<self
+                attr :#{name}
+              end
+            end_eval
+            return args.first
+          else
+            pre_gecoder_method_missing(method, *args)
+          end
         end
+        alias_method :mixin_method_missing, :method_missing
 
-        # We use the meta class to avoid defining the variable in all
-        # other instances of the class.
-        eval <<-"end_eval"
-          @#{name} = args.first
-          class <<self
-            attr :#{name}
+        def self.method_added(method)
+          if method == :method_missing && !@redefining_method_missing
+            # The class that is mixing in the mixin redefined method
+            # missing. Redefine method missing again to combine the two
+            # definitions.
+            @redefining_method_missing = true
+            class_eval do 
+              alias_method :mixee_method_missing, :method_missing
+              def combined_method_missing(*args)
+                begin
+                  mixin_method_missing(*args)
+                rescue NoMethodError => e
+                  mixee_method_missing(*args)
+                end
+              end
+              alias_method :method_missing, :combined_method_missing
+            end
           end
-        end_eval
-        return args.first
-      else
-        super
+        end
       end
     end
 
@@ -419,19 +452,19 @@ module Gecode
     
     # Retrieves the base from which searches are made. 
     def base_space
-      @base_space ||= Gecode::Raw::Space.new
+      @gecoder_mixin_base_space ||= Gecode::Raw::Space.new
     end
     
     # Retrieves the currently selected space, the one which constraints and 
     # variables should be bound to.
     def selected_space
-      return @active_space unless @active_space.nil?
+      return @gecoder_mixin_active_space unless @gecoder_mixin_active_space.nil?
       self.active_space = base_space
     end
     
     # Retrieves the space that should be used for variable creation.
     def variable_creation_space
-      @variable_creation_space || selected_space
+      @gecoder_mixin_variable_creation_space || selected_space
     end
     
     # Executes any interactions with Gecode still waiting in the queue 
@@ -444,10 +477,10 @@ module Gecode
     end
     
     # Switches the active space used (the space from which variables are read
-    # and to which constraints are posted). @active_space should never be 
-    # assigned directly.
+    # and to which constraints are posted). @gecoder_mixin_active_space 
+    # should never be assigned directly.
     def active_space=(new_space)
-      @active_space = new_space
-    end    
+      @gecoder_mixin_active_space = new_space
+    end
   end
 end