gecoder 0.2.0 → 0.3.0

data/lib/gecoder/interface/constraints/int_enum/distinct.rb

@@ -0,0 +1,66 @@
+module Gecode
+  module IntEnumMethods
+    # Specifies offsets to be used with a distinct constraint. The offsets can
+    # be specified one by one or as an array of offsets.
+    def with_offsets(*offsets)
+      if offsets.kind_of? Enumerable
+        offsets = *offsets
+      end
+      params = {:lhs => self, :offsets => offsets}
+      return Gecode::Constraints::IntEnum::Distinct::OffsetExpression.new(
+        @model, params)
+    end
+  end
+end
+
+module Gecode::Constraints::IntEnum
+  class Expression
+    # Posts a distinct constraint on the variables in the enum.
+    def distinct(options = {})
+      if @params[:negate]
+        # The best we could implement it as from here would be a bunch of 
+        # reified pairwise equality constraints. 
+        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
+          'implemented.'
+      end
+    
+      @model.add_constraint Distinct::DistinctConstraint.new(@model, 
+        @params.update(Gecode::Constraints::OptionUtil.decode_options(options)))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in distinct constraints.
+  module Distinct
+    # Describes an expression started with an int var enum following with
+    # #with_offsets .
+    class OffsetExpression < Gecode::Constraints::IntEnum::Expression
+      include Gecode::Constraints::LeftHandSideMethods
+      
+      def initialize(model, params)
+        @model = model
+        @params = params
+      end
+      
+      private
+      
+      # Produces an expression with offsets for the lhs module.
+      def expression(params)
+        params.update(@params)
+        Gecode::Constraints::IntEnum::Expression.new(@model, params)
+      end
+    end
+    
+    # Describes a distinct constraint (optionally with offsets).
+    class DistinctConstraint < Gecode::Constraints::Constraint
+      def post
+        # Bind lhs.
+        @params[:lhs] = @params[:lhs].to_int_var_array
+        
+        # Fetch the parameters to Gecode.
+        params = @params.values_at(:offsets, :lhs, :strength)
+        params.delete_if{ |x| x.nil? }
+        Gecode::Raw::distinct(@model.active_space, *params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Gecode
+  module IntEnumMethods
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::IntEnum::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have enumerations of integer 
+  # variables as left hand side.
+  module Constraints::IntEnum
+    # Expressions with int enums as left hand sides.
+    class Expression < Gecode::Constraints::Expression
+      # Raises TypeError unless the left hand side is an int enum.
+      def initialize(model, params)
+        super
+        
+        unless params[:lhs].respond_to? :to_int_var_array
+          raise TypeError, 'Must have int enum as left hand side.'
+        end
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int_enum/distinct'

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

@@ -0,0 +1,22 @@
+module Gecode
+  class FreeIntVar
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::Int::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have int variables as left hand side
+  # (but not enumerations).
+  module Constraints::Int
+    class Expression < Gecode::Constraints::Expression
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int/linear'

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

@@ -0,0 +1,57 @@
+module Gecode::Constraints
+  # Base class for all reifiable constraints.
+  class ReifiableConstraint < Constraint
+    # Gets the reification variable of the constraint, nil if none exists.
+    def reification_var
+      @params[:reif]
+    end
+    
+    # Sets the reification variable of the constraint, nil if none should be
+    # used.
+    def reification_var=(new_var)
+      @params[:reif] = new_var
+    end
+    
+    # Produces a disjunction of two reifiable constraints, producing a new
+    # reifiable constraint.
+    def |(constraint)
+      with_reification_variables(constraint) do |b1, b2|
+        # Create the disjunction constraint.
+        (b1 | b2).must_be.true
+      end
+    end
+    
+    # Produces a conjunction of two reifiable constraints, producing a new
+    # reifiable constraint.
+    def &(constraint)
+      with_reification_variables(constraint) do |b1, b2|
+        # Create the conjunction constraint.
+        (b1 & b2).must_be.true
+      end
+    end
+    
+    private
+    
+    # Yields two boolean variables to the specified block. The first one is 
+    # self's reification variable and the second one is the reification variable
+    # of the specified constraint. Reuses reification variables if possible,
+    # otherwise creates new ones.
+    def with_reification_variables(constraint, &block)
+      raise TypeError unless constraint.kind_of? ReifiableConstraint
+      
+      # Set up the reification variables, using existing variables if they 
+      # exist.
+      con1_holds = self.reification_var
+      con2_holds = constraint.reification_var
+      if con1_holds.nil?
+        con1_holds = @model.bool_var
+        self.reification_var = con1_holds
+      end
+      if con2_holds.nil?
+        con2_holds = @model.bool_var
+        constraint.reification_var = con2_holds
+      end
+      yield(con1_holds, con2_holds)
+    end
+  end
+end

data/lib/gecoder/interface/enum_wrapper.rb

@@ -8,32 +8,41 @@ module Gecode
       unless enum.kind_of? Enumerable
         raise TypeError, 'Only enumerables can be wrapped.'
       end
+      if enum.empty?
+        raise ArgumentError, 'Enumerable must not be empty.'
+      end
       
-      class <<enum
-        include Gecode::IntEnumConstraintMethods
+      if enum.first.kind_of? FreeIntVar
+        class <<enum
+          include Gecode::IntEnumMethods
+        end
+      elsif enum.first.kind_of? FreeBoolVar
+        class <<enum
+          include Gecode::BoolEnumMethods
+        end
+      else
+        raise TypeError, "Enumerable doesn't contain variables #{enum.inspect}."
       end
+      
       enum.model = self
       return enum
     end
   end
   
+  # A module containing the methods needed by enumerations containing variables.
+  module EnumMethods
+    attr_accessor :model
+    # Gets the current space of the model the array is connected to.
+    def active_space
+      @model.active_space
+    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
-    
+  module IntEnumMethods
+    include EnumMethods
+  
     # Returns an int variable array with all the bound variables.
     def to_int_var_array
       elements = to_a
@@ -41,24 +50,21 @@ module Gecode
       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
+    alias_method :to_var_array, :to_int_var_array
   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
+  # A module containing the methods needed by enumerations containing boolean
+  # variables. Requires that it's included in an enumerable.
+  module BoolEnumMethods
+    include EnumMethods
+  
+    # Returns a bool variable array with all the bound variables.
+    def to_bool_var_array
+      elements = to_a
+      arr = Gecode::Raw::BoolVarArray.new(active_space, elements.size)
+      elements.each_with_index{ |var, index| arr[index] = var.bind }
+      return arr
     end
+    alias_method :to_var_array, :to_bool_var_array
   end
 end

data/lib/gecoder/interface/model.rb

@@ -1,21 +1,9 @@
 module Gecode
-  # Model is the base class that all models must inherit from. The superclass
-  # constructor must be called.
+  # Model is the base class that all models must inherit from.
   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.
+    attr :constraints
+    protected :constraints
   
-    # 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)
@@ -38,6 +26,44 @@ module Gecode
       return wrap_enum(variables)
     end
     
+    # Creates a new boolean variable.
+    def bool_var(*domain_args)
+      index = active_space.new_bool_vars.first
+      FreeBoolVar.new(self, index)
+    end
+    
+    # Creates an array containing the specified number of boolean variables.
+    def bool_var_array(count)
+      variables = []
+      active_space.new_bool_vars(count).each do |index|
+        variables << FreeBoolVar.new(self, index)
+      end
+      return wrap_enum(variables)
+    end
+    
+    # Retrieves the currently active space (the one which variables refer to).
+    def active_space
+      @active_space ||= base_space
+    end
+    
+    # Retrieves the base from which searches are made. 
+    def base_space
+      @base_space ||= Gecode::Raw::Space.new
+    end
+    
+    # Adds the specified constraint to the model. Returns the newly added 
+    # constraint.
+    def add_constraint(constraint)
+      constraints << constraint
+      return constraint
+    end
+    
+    protected
+    
+    def constraints
+      @constraints ||= []
+    end
+    
     private
     
     # Returns the range of the specified domain arguments, which can either be
@@ -52,9 +78,11 @@ module Gecode
         max = domain_args.max
       else
         element = domain_args.first
-        if element.respond_to? :begin and element.respond_to? :end
+        if element.respond_to?(:begin) and element.respond_to?(:end) and
+            element.respond_to?(:exclude_end?)
           min = element.begin
           max = element.end
+          max -= 1 if element.exclude_end?
         else
           min = max = element
         end
@@ -79,52 +107,4 @@ module Gecode
       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

@@ -12,12 +12,49 @@ module Gecode
     # 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
+      space = dfs_engine.next
       return nil if space.nil?
       @active_space = space
       return self
     end
+    
+    # Returns to the original state, before any search was made (but propagation 
+    # might have been performed). Returns the reset model.
+    def reset!
+      @active_space = base_space
+      return self
+    end
+    
+    # Yields the first solution (if any) to the block. If no solution is found
+    # then the block is not used. Returns the result of the block (nil in case
+    # the block wasn't run). 
+    def solution(&block)
+      solution = self.solve!
+      res = yield solution unless solution.nil?
+      self.reset!
+      return res
+    end
+    
+    # Yields each solution that the model has.
+    def each_solution(&block)
+      dfs = dfs_engine
+      while not (@active_space = dfs.next).nil?
+        yield self
+      end
+      self.reset!
+    end
+    
+    private
+    
+    # Creates an DFS engine for the search, executing any unexecuted 
+    # constraints first.
+    def dfs_engine
+      # Execute constraints.
+      constraints.each{ |con| con.post }
+      constraints.clear # Empty the queue.
+    
+      stop = Gecode::Raw::Search::Stop.new
+      Gecode::Raw::DFS.new(active_space, COPY_DIST, ADAPTATION_DIST, stop)
+    end
   end
 end