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

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

@@ -0,0 +1,95 @@
+# A module containing constraints that have enumerations of integer 
+# operands as left hand side.
+module Gecode::IntEnum #:nodoc:
+  # A IntEnumOperand is a enumeration of IntOperand on which the
+  # 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
+  # by wrapping an existing enumeration containing IntOperand using
+  # Gecode::Model#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:
+  #
+  #   int_enum = int_var_array(5, 0..9)
+  #
+  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # a IntEnumOperand from an existing enumeration containing the
+  # integer operands +int_operand1+ and +int_operand2+:
+  #
+  #   int_enum = wrap_enum([int_operand1, int_operand2])
+  #   
+  #--
+  # Classes that mix in IntEnumOperand must define #model and
+  # #to_int_enum .
+  module IntEnumOperand
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::IntEnum::Dummy.instance_methods.include? method.to_s
+        # Delegate to the int enum.
+        to_int_enum.method(method).call(*args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def construct_receiver(params)
+      IntEnumConstraintReceiver.new(@model, params)
+    end
+  end
+
+  # IntEnumConstraintReceiver contains all constraints that can be
+  # placed on a IntEnumOperand.
+  #
+  # Constraints are placed by calling IntEnumOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # IntEnumConstraintReceiver from which the desired constraint can be used.
+  #
+  # Some constraint accepts a number of options. See ConstraintReceiver
+  # for more information.
+  #
+  # ==== Examples 
+  #
+  # Constrains the integer operands in +int_enum+ to take on different
+  # values by using IntEnumConstraintReceiver#distinct:
+  #
+  #   int_enum.must_be.distinct
+  #
+  # Constrains +int_enum2+ to have the same elements as +int_enum+, but
+  # sorted in ascending order. Uses IntEnumConstraintReceiver#sorted:
+  #
+  #   int_enum.must_be.sorted(:as => int_enum2)
+  #
+  # The same as above, but specifying that strength :domain should be 
+  # used and that the constraint should be reified with +bool_operand+:
+  #
+  #   int_enum.must_be.sorted(:as => int_enum2, :strength => :domain, :reify => bool_operand)
+  #
+  class IntEnumConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is an int enum
+    # operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_int_enum
+        raise TypeError, 'Must have int enum operand as left hand side.'
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int_enum/distinct'
+require 'gecoder/interface/constraints/int_enum/equality'
+require 'gecoder/interface/constraints/int_enum/channel'
+require 'gecoder/interface/constraints/int_enum/element'
+require 'gecoder/interface/constraints/int_enum/count'
+require 'gecoder/interface/constraints/int_enum/sort'
+require 'gecoder/interface/constraints/int_enum/arithmetic'
+require 'gecoder/interface/constraints/int_enum/extensional'

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

@@ -0,0 +1,230 @@
+# A module that deals with the operands, properties and constraints of
+# integer variables.
+module Gecode::Int #:nodoc:
+  # A IntOperand is a combination of variables on which the
+  # 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
+  # integer operands. The operands, no matter how they were created, 
+  # all respond to the properties defined by IntOperand.
+  #
+  # ==== Examples 
+  #
+  # Produces a single integer operand (more specifically an IntVar) with
+  # domain 0..9 inside a problem formulation, using
+  # Gecode::Model#int_var:
+  #
+  #   int_operand = int_var(0..9)
+  #
+  # Uses the IntOperand#+ property to produce a new integer
+  # operand representing +int_operand1+ plus +int_operand2+:
+  #
+  #   new_int_operand = int_operand1 + int_operand2
+  #
+  # Uses the IntEnumOperand#max property to produce a new
+  # integer operand representing the maximum value of the integer operands
+  # in the enumeration +int_enum+:
+  # 
+  #   new_int_operand = int_enum.max
+  #
+  # Uses the IntEnumOperand#[] property to produce a new integer operand
+  # representing the integer operand at the index decided by
+  # +int_operand+ (which can change during search) in the enumeration
+  # +int_enum+:
+  # 
+  #   new_int_operand = int_enum[int_operand]
+  #
+  # Uses the SetOperand#size property to produce a new integer operand
+  # representing the size of +set_operand+:
+  #
+  #   new_int_operand = set_operand.size
+  #
+  #--
+  # Classes that mix in IntOperand must define #model and #to_int_var .
+  module IntOperand  
+    include Gecode::Operand 
+
+    def method_missing(method, *args) #:nodoc:
+      if Gecode::IntVar.instance_methods.include? method.to_s
+        # Delegate to the int var.
+        to_int_var.method(method).call(*args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def construct_receiver(params)
+      IntConstraintReceiver.new(model, params)
+    end
+  end
+
+  # An operand that short circuits integer equality.
+  class ShortCircuitEqualityOperand #:nodoc:
+    include Gecode::Int::IntOperand
+    attr :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def construct_receiver(params)
+      params.update(:lhs => self)
+      receiver = IntConstraintReceiver.new(@model, params)
+      op = self
+      receiver.instance_eval{ @short_circuit = op }
+      class <<receiver
+        alias_method :equality_without_short_circuit, :==
+        def ==(operand, options = {})
+          if !@params[:negate] and options[:reify].nil? and 
+              operand.respond_to? :to_int_var
+            # Short circuit the constraint.
+            @params.update Gecode::Util.decode_options(options)
+            @model.add_constraint(Gecode::BlockConstraint.new(
+                @model, @params) do
+              @short_circuit.constrain_equal(operand, false,
+                @params.values_at(:strength, :kind))
+            end)
+          else
+            equality_without_short_circuit(operand, options)
+          end
+        end
+        alias_comparison_methods
+      end
+
+      return receiver
+    end
+
+    def to_int_var
+      variable = model.int_var
+      options = 
+        Gecode::Util.decode_options({}).values_at(:strength, :kind)
+      model.add_interaction do
+        constrain_equal(variable, true, options)
+      end
+      return variable
+    end
+
+    private
+
+    # Constrains this operand to equal +int_operand+ using the
+    # specified +propagation_options+. If +constrain_domain+ is true
+    # then the method should also attempt to constrain the bounds of the
+    # domain of +int_operand+.
+    def constrain_equal(int_operand, constrain_domain, propagation_options)
+      raise NotImplementedError, 'Abstract method has not been implemented.'
+    end
+  end
+
+  # An operand that short circuits integer relation constraints.
+  class ShortCircuitRelationsOperand #:nodoc:
+    include Gecode::Int::IntOperand
+    attr :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def construct_receiver(params)
+      receiver = IntConstraintReceiver.new(@model, params)
+      op = self
+      receiver.instance_eval{ @short_circuit = op }
+      class <<receiver
+        Gecode::Util::COMPARISON_ALIASES.keys.each do |comp|
+          eval <<-end_code
+            alias_method :alias_#{comp.to_i}_without_short_circuit, :#{comp}
+            def #{comp}(operand, options = {})
+              if operand.respond_to?(:to_int_var) or operand.kind_of? Fixnum
+                # Short circuit the constraint.
+                @params.update Gecode::Util.decode_options(options)
+                @model.add_constraint(
+                  @short_circuit.relation_constraint(
+                    :#{comp}, operand, @params))
+              else
+                alias_#{comp.to_i}_without_short_circuit(operand, options)
+              end
+            end
+          end_code
+        end
+        alias_comparison_methods
+      end
+
+      return receiver
+    end
+
+    def to_int_var
+      variable = model.int_var
+      params = {}
+      params.update Gecode::Util.decode_options({})
+      model.add_constraint relation_constraint(:==, variable, params)
+      return variable
+    end
+
+    # Returns a constraint that constrains this operand to have relation
+    # +relation+ to +int_operand_or_fix+, which is either an integer 
+    # operand or a fixnum, given the specified hash +params+ of parameters.
+    def relation_constraint(relation, int_operand_or_fix, params)
+      raise NotImplementedError, 'Abstract method has not been implemented.'
+    end
+  end
+
+  # IntConstraintReceiver contains all constraints that can be
+  # placed on an IntOperand.
+  #
+  # Constraints are placed by calling IntOperand#must (or any other
+  # of the variations defined in Operand), which produces a 
+  # IntConstraintReceiver from which the desired constraint can be used.
+  #
+  # Each constraint accepts a number of options. See ConstraintReceiver
+  # for more information.
+  #
+  # ==== Examples 
+  #
+  # Constrains +int_operand+ to be strictly greater than 5 using
+  # IntConstraintReceiver#>:
+  #
+  #   int_operand.must > 5
+  #
+  # Constrains +int_operand1+ plus +int_operand2+ to be strictly 
+  # greater than 5 using the IntOperand#+ property and 
+  # IntConstraintReceiver#>:
+  #
+  #   (int_operand1 + int_operand2).must > 5
+  #
+  # Constrains the maximum value of the integer operands in +int_enum+ to
+  # _not_ be in the range 3..7 using the IntEnumOperand#max property and 
+  # IntConstraintReceiver#in:
+  #
+  #   int_enum.max.must_not_be.in 3..7
+  #
+  # Constrains the integer operand at position +int_operand+ in
+  # +int_enum+, an enumeration of integer operands, to be greater than
+  # or equal to +int_operand2+. This uses the IntEnumOperand#[] property 
+  # and IntConstraintReceiver#>=:
+  #
+  #   int_enum[int_operand].must >= int_operand2
+  #
+  # The same as above, but specifying that strength :domain should be 
+  # used and that the constraint should be reified with +bool_operand+:
+  #
+  #   int_enum[int_operand].must_be.greater_or_equal(int_operand2, :strength => :domain, :reify => bool_operand)
+  #
+  class IntConstraintReceiver < Gecode::ConstraintReceiver
+    # Raises TypeError unless the left hand side is an int operand.
+    def initialize(model, params) #:nodoc:
+      super
+
+      unless params[:lhs].respond_to? :to_int_var
+        raise TypeError, 'Must have int operand as left hand side.'
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/int/relation'
+require 'gecoder/interface/constraints/int/linear'
+require 'gecoder/interface/constraints/int/domain'
+require 'gecoder/interface/constraints/int/arithmetic'
+require 'gecoder/interface/constraints/int/channel'

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

@@ -0,0 +1,78 @@
+module Gecode
+  # Base class for all reifiable constraints.
+  class ReifiableConstraint < Constraint #:nodoc:
+    # Gets the reification operand of the constraint, nil if none exists.
+    def reification_var
+      @params[:reif]
+    end
+    
+    # Sets the reification operand 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_operands(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_operands(constraint) do |b1, b2|
+        # Create the conjunction constraint.
+        (b1 & b2).must_be.true
+      end
+    end
+    
+    private
+    
+    # Yields two boolean operands to the specified block. The first one
+    # is self's reification operand and the second one is the
+    # reification operand of the specified constraint. Reuses
+    # reification operands if possible, otherwise creates new ones.
+    def with_reification_operands(constraint, &block)
+      raise TypeError unless constraint.kind_of? ReifiableConstraint
+      
+      # Set up the reification operands, using existing operands 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
+    
+    # If called the negation of the constraint will be handled using the 
+    # reification operand. This means that the post method (which has to be 
+    # defined prior to calling this method) doesn't have to bother about 
+    # negation.
+    def self.negate_using_reification
+      class_eval do
+        alias_method :post_without_negation, :post
+        
+        def post
+          if @params[:negate]
+            if @params[:reif].nil?
+              # Create a reification variable if none exists.
+              @params[:reif] = @model.bool_var
+            end
+            @params[:reif].must_be.false
+          end
+          post_without_negation
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Gecode::SelectedSet
+  class SelectedSetOperand
+    # Produces a SetOperand representing the selected sets' union.
+    #
+    # ==== Examples 
+    #
+    #   # The union of all sets selected by +set_enum[set]+.
+    #   set_enum[set].union
+    def union
+      Select::SelectedSetUnionOperand.new(model, self)
+    end
+     
+    # Produces a SetOperand representing the selected sets' intersection.
+    # The option :with can be used to enumerate the elements in the
+    # universe.
+    #
+    # ==== Examples 
+    #
+    #   # The intersection of all sets selected by +set_enum[set]+.
+    #   set_enum[set].intersection
+    #
+    #   # The same intersection as above, but with [3,5,7] as universe.
+    #   set_enum[set].intersection(:with => [3,5,7])
+    def intersection(options = {})
+      universe = nil
+      unless options.empty? 
+        unless options.size == 1 and options.has_key?(:with)
+          raise ArgumentError, "Expected option key :with, got #{options.keys}."
+        else
+          universe = options[:with]
+          unless universe.kind_of?(Enumerable) and 
+              universe.all?{ |element| element.kind_of? Fixnum }
+            raise TypeError, "Expected the universe to be specified as " + 
+              "an enumeration of fixnum, got #{universe.class}."
+          end
+        end
+      end
+      
+      Select::SelectedSetIntersectionOperand.new(model, self, universe)
+    end
+  end
+
+  class SelectedSetConstraintReceiver
+    # Constrains the selected sets to be pairwise disjoint.
+    #
+    # ==== Examples 
+    #
+    #   # Constrains all sets selected by +set_enum[set]+ to be pairwise
+    #   # disjoint.
+    #   set_enum[set].must_be.disjoint 
+    def disjoint(options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated disjoint constraint ' + 
+          'is not implemented.'
+      end
+      if options.has_key? :reify
+        raise ArgumentError, 'The disjoint constraint does not support the ' + 
+          'reification option.'
+      end
+
+      @params.update Gecode::Set::Util.decode_options(options)
+      @model.add_constraint Select::DisjointConstraint.new(@model, @params)
+    end
+  end
+
+  module Select #:nodoc:
+    class SelectedSetUnionOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, selected_set)
+        super model
+        @selected_set = selected_set
+      end
+
+      def constrain_equal(set_operand, constrain, propagation_options)
+        enum, indices = @selected_set.to_selected_set
+        if constrain
+          set_operand.must_be.subset_of enum.upper_bound_range
+        end
+        
+        Gecode::Raw::selectUnion(@model.active_space, 
+          enum.to_set_enum.bind_array, indices.to_set_var.bind, 
+          set_operand.to_set_var.bind)
+      end
+    end
+    
+    class SelectedSetIntersectionOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, selected_set, universe)
+        super model
+        @selected_set = selected_set
+        @universe = universe
+      end
+
+      def constrain_equal(set_operand, constrain, propagation_options)
+        enum, indices = @selected_set.to_selected_set
+        universe = @universe
+
+        # We can't do any useful constraining here since the empty intersection
+        # is the universe.
+
+        if universe.nil?
+          Gecode::Raw::selectInter(@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,  
+            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))
+        end
+      end
+    end
+    
+    class DisjointConstraint < Gecode::Constraint #:nodoc:
+      def post
+        enum, indices = @params[:lhs].to_selected_set
+        Gecode::Raw.selectDisjoint(@model.active_space, 
+          enum.to_set_enum.bind_array, indices.to_set_var.bind)
+      end
+    end
+  end
+end